<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[172730] trunk/Source/WebCore</title>
</head>
<body>
<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/172730">172730</a></dd>
<dt>Author</dt> <dd>antti@apple.com</dd>
<dt>Date</dt> <dd>2014-08-18 15:16:47 -0700 (Mon, 18 Aug 2014)</dd>
</dl>
<h3>Log Message</h3>
<pre>Tighten RenderCounter typing
https://bugs.webkit.org/show_bug.cgi?id=136049
Reviewed by Andreas Kling.
RenderObject* -> RenderElement&
* rendering/CounterNode.cpp:
(WebCore::CounterNode::CounterNode):
(WebCore::CounterNode::create):
(WebCore::showTreeAndMark):
* rendering/CounterNode.h:
(WebCore::CounterNode::owner):
* rendering/RenderCounter.cpp:
(WebCore::previousInPreOrder):
(WebCore::parentOrPseudoHostElement):
(WebCore::previousSiblingOrParent):
(WebCore::areRenderersElementsSiblings):
(WebCore::nextInPreOrder):
(WebCore::planCounter):
(WebCore::findPlaceForCounter):
(WebCore::makeCounterNode):
(WebCore::RenderCounter::originalText):
(WebCore::destroyCounterNodeWithoutMapRemoval):
(WebCore::RenderCounter::destroyCounterNodes):
(WebCore::RenderCounter::destroyCounterNode):
(WebCore::RenderCounter::rendererRemovedFromTree):
(WebCore::updateCounters):
(WebCore::RenderCounter::rendererSubtreeAttached):
(WebCore::RenderCounter::rendererStyleChanged):
(showCounterRendererTree):
* rendering/RenderCounter.h:
* rendering/RenderElement.cpp:
(WebCore::RenderElement::RenderElement):
(WebCore::RenderElement::insertChildInternal):
(WebCore::RenderElement::removeChildInternal):
(WebCore::RenderElement::styleDidChange):
(WebCore::RenderElement::willBeDestroyed):
* rendering/RenderElement.h:
(WebCore::RenderElement::hasCounterNodeMap):
(WebCore::RenderElement::setHasCounterNodeMap):
Move CounterNodeMap to RenderElement from RenderObject.
* rendering/RenderObject.cpp:
(WebCore::RenderObject::willBeDestroyed):
* rendering/RenderObject.h:
(WebCore::RenderObject::RenderObjectBitfields::RenderObjectBitfields):
(WebCore::RenderObject::hasCounterNodeMap): Deleted.
(WebCore::RenderObject::setHasCounterNodeMap): Deleted.</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceWebCoreChangeLog">trunk/Source/WebCore/ChangeLog</a></li>
<li><a href="#trunkSourceWebCorerenderingCounterNodecpp">trunk/Source/WebCore/rendering/CounterNode.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingCounterNodeh">trunk/Source/WebCore/rendering/CounterNode.h</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderCountercpp">trunk/Source/WebCore/rendering/RenderCounter.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderCounterh">trunk/Source/WebCore/rendering/RenderCounter.h</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderElementcpp">trunk/Source/WebCore/rendering/RenderElement.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderElementh">trunk/Source/WebCore/rendering/RenderElement.h</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderObjectcpp">trunk/Source/WebCore/rendering/RenderObject.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderObjecth">trunk/Source/WebCore/rendering/RenderObject.h</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceWebCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/ChangeLog (172729 => 172730)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/ChangeLog 2014-08-18 22:03:24 UTC (rev 172729)
+++ trunk/Source/WebCore/ChangeLog 2014-08-18 22:16:47 UTC (rev 172730)
</span><span class="lines">@@ -1,3 +1,56 @@
</span><ins>+2014-08-18 Antti Koivisto <antti@apple.com>
+
+ Tighten RenderCounter typing
+ https://bugs.webkit.org/show_bug.cgi?id=136049
+
+ Reviewed by Andreas Kling.
+
+ RenderObject* -> RenderElement&
+
+ * rendering/CounterNode.cpp:
+ (WebCore::CounterNode::CounterNode):
+ (WebCore::CounterNode::create):
+ (WebCore::showTreeAndMark):
+ * rendering/CounterNode.h:
+ (WebCore::CounterNode::owner):
+ * rendering/RenderCounter.cpp:
+ (WebCore::previousInPreOrder):
+ (WebCore::parentOrPseudoHostElement):
+ (WebCore::previousSiblingOrParent):
+ (WebCore::areRenderersElementsSiblings):
+ (WebCore::nextInPreOrder):
+ (WebCore::planCounter):
+ (WebCore::findPlaceForCounter):
+ (WebCore::makeCounterNode):
+ (WebCore::RenderCounter::originalText):
+ (WebCore::destroyCounterNodeWithoutMapRemoval):
+ (WebCore::RenderCounter::destroyCounterNodes):
+ (WebCore::RenderCounter::destroyCounterNode):
+ (WebCore::RenderCounter::rendererRemovedFromTree):
+ (WebCore::updateCounters):
+ (WebCore::RenderCounter::rendererSubtreeAttached):
+ (WebCore::RenderCounter::rendererStyleChanged):
+ (showCounterRendererTree):
+ * rendering/RenderCounter.h:
+ * rendering/RenderElement.cpp:
+ (WebCore::RenderElement::RenderElement):
+ (WebCore::RenderElement::insertChildInternal):
+ (WebCore::RenderElement::removeChildInternal):
+ (WebCore::RenderElement::styleDidChange):
+ (WebCore::RenderElement::willBeDestroyed):
+ * rendering/RenderElement.h:
+ (WebCore::RenderElement::hasCounterNodeMap):
+ (WebCore::RenderElement::setHasCounterNodeMap):
+
+ Move CounterNodeMap to RenderElement from RenderObject.
+
+ * rendering/RenderObject.cpp:
+ (WebCore::RenderObject::willBeDestroyed):
+ * rendering/RenderObject.h:
+ (WebCore::RenderObject::RenderObjectBitfields::RenderObjectBitfields):
+ (WebCore::RenderObject::hasCounterNodeMap): Deleted.
+ (WebCore::RenderObject::setHasCounterNodeMap): Deleted.
+
</ins><span class="cx"> 2014-08-18 Peyton Randolph <prandolph@apple.com>
</span><span class="cx">
</span><span class="cx"> Expose long mouse press WebKit API. Part of 135257 - Add long mouse press gesture
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingCounterNodecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/CounterNode.cpp (172729 => 172730)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/CounterNode.cpp 2014-08-18 22:03:24 UTC (rev 172729)
+++ trunk/Source/WebCore/rendering/CounterNode.cpp 2014-08-18 22:16:47 UTC (rev 172730)
</span><span class="lines">@@ -28,11 +28,11 @@
</span><span class="cx">
</span><span class="cx"> namespace WebCore {
</span><span class="cx">
</span><del>-CounterNode::CounterNode(RenderElement* o, bool hasResetType, int value)
</del><ins>+CounterNode::CounterNode(RenderElement& owner, bool hasResetType, int value)
</ins><span class="cx"> : m_hasResetType(hasResetType)
</span><span class="cx"> , m_value(value)
</span><span class="cx"> , m_countInParent(0)
</span><del>- , m_owner(o)
</del><ins>+ , m_owner(owner)
</ins><span class="cx"> , m_rootRenderer(0)
</span><span class="cx"> , m_parent(0)
</span><span class="cx"> , m_previousSibling(0)
</span><span class="lines">@@ -90,7 +90,7 @@
</span><span class="cx"> resetRenderers();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-PassRefPtr<CounterNode> CounterNode::create(RenderElement* owner, bool hasResetType, int value)
</del><ins>+PassRefPtr<CounterNode> CounterNode::create(RenderElement& owner, bool hasResetType, int value)
</ins><span class="cx"> {
</span><span class="cx"> return adoptRef(new CounterNode(owner, hasResetType, value));
</span><span class="cx"> }
</span><span class="lines">@@ -365,7 +365,7 @@
</span><span class="cx"> fprintf(stderr, "%p %s: %d %d P:%p PS:%p NS:%p R:%p\n",
</span><span class="cx"> current, current->actsAsReset() ? "reset____" : "increment", current->value(),
</span><span class="cx"> current->countInParent(), current->parent(), current->previousSibling(),
</span><del>- current->nextSibling(), current->owner());
</del><ins>+ current->nextSibling(), &current->owner());
</ins><span class="cx"> }
</span><span class="cx"> fflush(stderr);
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingCounterNodeh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/CounterNode.h (172729 => 172730)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/CounterNode.h 2014-08-18 22:03:24 UTC (rev 172729)
+++ trunk/Source/WebCore/rendering/CounterNode.h 2014-08-18 22:16:47 UTC (rev 172730)
</span><span class="lines">@@ -42,13 +42,13 @@
</span><span class="cx">
</span><span class="cx"> class CounterNode : public RefCounted<CounterNode> {
</span><span class="cx"> public:
</span><del>- static PassRefPtr<CounterNode> create(RenderElement*, bool isReset, int value);
</del><ins>+ static PassRefPtr<CounterNode> create(RenderElement&, bool isReset, int value);
</ins><span class="cx"> ~CounterNode();
</span><span class="cx"> bool actsAsReset() const { return m_hasResetType || !m_parent; }
</span><span class="cx"> bool hasResetType() const { return m_hasResetType; }
</span><span class="cx"> int value() const { return m_value; }
</span><span class="cx"> int countInParent() const { return m_countInParent; }
</span><del>- RenderElement* owner() const { return m_owner; }
</del><ins>+ RenderElement& owner() const { return m_owner; }
</ins><span class="cx"> void addRenderer(RenderCounter*);
</span><span class="cx"> void removeRenderer(RenderCounter*);
</span><span class="cx">
</span><span class="lines">@@ -71,7 +71,7 @@
</span><span class="cx"> void removeChild(CounterNode*);
</span><span class="cx">
</span><span class="cx"> private:
</span><del>- CounterNode(RenderElement*, bool isReset, int value);
</del><ins>+ CounterNode(RenderElement&, bool isReset, int value);
</ins><span class="cx"> int computeCountInParent() const;
</span><span class="cx"> // Invalidates the text in the renderer of this counter, if any,
</span><span class="cx"> // and in the renderers of all descendants of this counter, if any.
</span><span class="lines">@@ -81,7 +81,7 @@
</span><span class="cx"> bool m_hasResetType;
</span><span class="cx"> int m_value;
</span><span class="cx"> int m_countInParent;
</span><del>- RenderElement* m_owner;
</del><ins>+ RenderElement& m_owner;
</ins><span class="cx"> RenderCounter* m_rootRenderer;
</span><span class="cx">
</span><span class="cx"> CounterNode* m_parent;
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderCountercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderCounter.cpp (172729 => 172730)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderCounter.cpp 2014-08-18 22:03:24 UTC (rev 172729)
+++ trunk/Source/WebCore/rendering/RenderCounter.cpp 2014-08-18 22:16:47 UTC (rev 172730)
</span><span class="lines">@@ -44,9 +44,9 @@
</span><span class="cx"> using namespace HTMLNames;
</span><span class="cx">
</span><span class="cx"> typedef HashMap<AtomicString, RefPtr<CounterNode>> CounterMap;
</span><del>-typedef HashMap<const RenderObject*, std::unique_ptr<CounterMap>> CounterMaps;
</del><ins>+typedef HashMap<const RenderElement*, std::unique_ptr<CounterMap>> CounterMaps;
</ins><span class="cx">
</span><del>-static CounterNode* makeCounterNode(RenderObject*, const AtomicString& identifier, bool alwaysCreateCounter);
</del><ins>+static CounterNode* makeCounterNode(RenderElement&, const AtomicString& identifier, bool alwaysCreateCounter);
</ins><span class="cx">
</span><span class="cx"> static CounterMaps& counterMaps()
</span><span class="cx"> {
</span><span class="lines">@@ -56,68 +56,64 @@
</span><span class="cx">
</span><span class="cx"> // This function processes the renderer tree in the order of the DOM tree
</span><span class="cx"> // including pseudo elements as defined in CSS 2.1.
</span><del>-static RenderObject* previousInPreOrder(const RenderObject* object)
</del><ins>+static RenderElement* previousInPreOrder(const RenderElement& renderer)
</ins><span class="cx"> {
</span><del>- Element* self = toElement(object->node());
- Element* previous = ElementTraversal::previousIncludingPseudo(self);
</del><ins>+ Element* previous = ElementTraversal::previousIncludingPseudo(renderer.element());
</ins><span class="cx"> while (previous && !previous->renderer())
</span><span class="cx"> previous = ElementTraversal::previousIncludingPseudo(previous);
</span><span class="cx"> return previous ? previous->renderer() : 0;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static inline Element* parentOrPseudoHostElement(const RenderObject* object)
</del><ins>+static inline Element* parentOrPseudoHostElement(const RenderElement& renderer)
</ins><span class="cx"> {
</span><del>- if (object->node()->isPseudoElement())
- return toPseudoElement(object->node())->hostElement();
- return toElement(object->node())->parentElement();
</del><ins>+ if (renderer.isPseudoElement())
+ return renderer.generatingElement();
+ return renderer.element() ? renderer.element()->parentElement() : nullptr;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // This function processes the renderer tree in the order of the DOM tree
</span><span class="cx"> // including pseudo elements as defined in CSS 2.1.
</span><del>-static RenderObject* previousSiblingOrParent(const RenderObject* object)
</del><ins>+static RenderElement* previousSiblingOrParent(const RenderElement& renderer)
</ins><span class="cx"> {
</span><del>- Element* self = toElement(object->node());
- Element* previous = ElementTraversal::pseudoAwarePreviousSibling(self);
</del><ins>+ Element* previous = ElementTraversal::pseudoAwarePreviousSibling(renderer.element());
</ins><span class="cx"> while (previous && !previous->renderer())
</span><span class="cx"> previous = ElementTraversal::pseudoAwarePreviousSibling(previous);
</span><span class="cx"> if (previous)
</span><span class="cx"> return previous->renderer();
</span><del>- previous = parentOrPseudoHostElement(object);
- return previous ? previous->renderer() : 0;
</del><ins>+ previous = parentOrPseudoHostElement(renderer);
+ return previous ? previous->renderer() : nullptr;
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-static inline bool areRenderersElementsSiblings(RenderObject* first, RenderObject* second)
</del><ins>+static inline bool areRenderersElementsSiblings(const RenderElement& first, const RenderElement& second)
</ins><span class="cx"> {
</span><span class="cx"> return parentOrPseudoHostElement(first) == parentOrPseudoHostElement(second);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // This function processes the renderer tree in the order of the DOM tree
</span><span class="cx"> // including pseudo elements as defined in CSS 2.1.
</span><del>-static RenderElement* nextInPreOrder(const RenderElement* element, const Element* stayWithin, bool skipDescendants = false)
</del><ins>+static RenderElement* nextInPreOrder(const RenderElement& renderer, const Element* stayWithin, bool skipDescendants = false)
</ins><span class="cx"> {
</span><del>- Element* self = element->element();
</del><ins>+ Element* self = renderer.element();
</ins><span class="cx"> Element* next = skipDescendants ? ElementTraversal::nextIncludingPseudoSkippingChildren(self, stayWithin) : ElementTraversal::nextIncludingPseudo(self, stayWithin);
</span><span class="cx"> while (next && !next->renderer())
</span><span class="cx"> next = skipDescendants ? ElementTraversal::nextIncludingPseudoSkippingChildren(next, stayWithin) : ElementTraversal::nextIncludingPseudo(next, stayWithin);
</span><span class="cx"> return next ? next->renderer() : 0;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static bool planCounter(RenderElement* object, const AtomicString& identifier, bool& isReset, int& value)
</del><ins>+static bool planCounter(RenderElement& renderer, const AtomicString& identifier, bool& isReset, int& value)
</ins><span class="cx"> {
</span><del>- ASSERT(object);
-
</del><span class="cx"> // We must have a generating node or else we cannot have a counter.
</span><del>- Element* generatingElement = object->generatingElement();
</del><ins>+ Element* generatingElement = renderer.generatingElement();
</ins><span class="cx"> if (!generatingElement)
</span><span class="cx"> return false;
</span><span class="cx">
</span><del>- const RenderStyle& style = object->style();
</del><ins>+ const RenderStyle& style = renderer.style();
</ins><span class="cx">
</span><span class="cx"> switch (style.styleType()) {
</span><span class="cx"> case NOPSEUDO:
</span><span class="cx"> // Sometimes elements have more then one renderer. Only the first one gets the counter
</span><span class="cx"> // LayoutTests/http/tests/css/counter-crash.html
</span><del>- if (generatingElement->renderer() != object)
</del><ins>+ if (generatingElement->renderer() != &renderer)
</ins><span class="cx"> return false;
</span><span class="cx"> break;
</span><span class="cx"> case BEFORE:
</span><span class="lines">@@ -135,9 +131,9 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (identifier == "list-item") {
</span><del>- if (object->isListItem()) {
- if (toRenderListItem(object)->hasExplicitValue()) {
- value = toRenderListItem(object)->explicitValue();
</del><ins>+ if (renderer.isListItem()) {
+ if (toRenderListItem(renderer).hasExplicitValue()) {
+ value = toRenderListItem(renderer).explicitValue();
</ins><span class="cx"> isReset = true;
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="lines">@@ -145,13 +141,13 @@
</span><span class="cx"> isReset = false;
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><del>- if (Element* e = object->element()) {
- if (e->hasTagName(olTag)) {
- value = toHTMLOListElement(e)->start();
</del><ins>+ if (Element* element = renderer.element()) {
+ if (element->hasTagName(olTag)) {
+ value = toHTMLOListElement(element)->start();
</ins><span class="cx"> isReset = true;
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><del>- if (e->hasTagName(ulTag) || e->hasTagName(menuTag) || e->hasTagName(dirTag)) {
</del><ins>+ if (element->hasTagName(ulTag) || element->hasTagName(menuTag) || element->hasTagName(dirTag)) {
</ins><span class="cx"> value = 0;
</span><span class="cx"> isReset = true;
</span><span class="cx"> return true;
</span><span class="lines">@@ -178,20 +174,20 @@
</span><span class="cx"> // reset node.
</span><span class="cx"> // - Non-reset CounterNodes cannot have descendants.
</span><span class="cx">
</span><del>-static bool findPlaceForCounter(RenderObject* counterOwner, const AtomicString& identifier, bool isReset, RefPtr<CounterNode>& parent, RefPtr<CounterNode>& previousSibling)
</del><ins>+static bool findPlaceForCounter(RenderElement& counterOwner, const AtomicString& identifier, bool isReset, RefPtr<CounterNode>& parent, RefPtr<CounterNode>& previousSibling)
</ins><span class="cx"> {
</span><span class="cx"> // We cannot stop searching for counters with the same identifier before we also
</span><span class="cx"> // check this renderer, because it may affect the positioning in the tree of our counter.
</span><del>- RenderObject* searchEndRenderer = previousSiblingOrParent(counterOwner);
</del><ins>+ RenderElement* searchEndRenderer = previousSiblingOrParent(counterOwner);
</ins><span class="cx"> // We check renderers in preOrder from the renderer that our counter is attached to
</span><span class="cx"> // towards the begining of the document for counters with the same identifier as the one
</span><span class="cx"> // we are trying to find a place for. This is the next renderer to be checked.
</span><del>- RenderObject* currentRenderer = previousInPreOrder(counterOwner);
</del><ins>+ RenderElement* currentRenderer = previousInPreOrder(counterOwner);
</ins><span class="cx"> previousSibling = 0;
</span><span class="cx"> RefPtr<CounterNode> previousSiblingProtector = 0;
</span><span class="cx">
</span><span class="cx"> while (currentRenderer) {
</span><del>- CounterNode* currentCounter = makeCounterNode(currentRenderer, identifier, false);
</del><ins>+ CounterNode* currentCounter = makeCounterNode(*currentRenderer, identifier, false);
</ins><span class="cx"> if (searchEndRenderer == currentRenderer) {
</span><span class="cx"> // We may be at the end of our search.
</span><span class="cx"> if (currentCounter) {
</span><span class="lines">@@ -199,7 +195,7 @@
</span><span class="cx"> if (previousSiblingProtector) { // But we already found another counter that we come after.
</span><span class="cx"> if (currentCounter->actsAsReset()) {
</span><span class="cx"> // We found a reset counter that is on a renderer that is a sibling of ours or a parent.
</span><del>- if (isReset && areRenderersElementsSiblings(currentRenderer, counterOwner)) {
</del><ins>+ if (isReset && areRenderersElementsSiblings(*currentRenderer, counterOwner)) {
</ins><span class="cx"> // We are also a reset counter and the previous reset was on a sibling renderer
</span><span class="cx"> // hence we are the next sibling of that counter if that reset is not a root or
</span><span class="cx"> // we are a root node if that reset is a root.
</span><span class="lines">@@ -220,7 +216,7 @@
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx"> // CurrentCounter, the counter at the EndSearchRenderer, is not reset.
</span><del>- if (!isReset || !areRenderersElementsSiblings(currentRenderer, counterOwner)) {
</del><ins>+ if (!isReset || !areRenderersElementsSiblings(*currentRenderer, counterOwner)) {
</ins><span class="cx"> // If the node we are placing is not reset or we have found a counter that is attached
</span><span class="cx"> // to an ancestor of the placed counter's owner renderer we know we are a sibling of that node.
</span><span class="cx"> if (currentCounter->parent() != previousSiblingProtector->parent())
</span><span class="lines">@@ -236,7 +232,7 @@
</span><span class="cx"> // previousSibling, and when we are a sibling of the end counter we must set previousSibling
</span><span class="cx"> // to currentCounter.
</span><span class="cx"> if (currentCounter->actsAsReset()) {
</span><del>- if (isReset && areRenderersElementsSiblings(currentRenderer, counterOwner)) {
</del><ins>+ if (isReset && areRenderersElementsSiblings(*currentRenderer, counterOwner)) {
</ins><span class="cx"> parent = currentCounter->parent();
</span><span class="cx"> previousSibling = currentCounter;
</span><span class="cx"> return parent;
</span><span class="lines">@@ -245,7 +241,7 @@
</span><span class="cx"> previousSibling = previousSiblingProtector.get();
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><del>- if (!isReset || !areRenderersElementsSiblings(currentRenderer, counterOwner)) {
</del><ins>+ if (!isReset || !areRenderersElementsSiblings(*currentRenderer, counterOwner)) {
</ins><span class="cx"> parent = currentCounter->parent();
</span><span class="cx"> previousSibling = currentCounter;
</span><span class="cx"> return true;
</span><span class="lines">@@ -257,7 +253,7 @@
</span><span class="cx"> // good counter, or we are a reset node and the counter on the previous sibling
</span><span class="cx"> // of our owner renderer was not a reset counter.
</span><span class="cx"> // Set a new goal for the end of the search.
</span><del>- searchEndRenderer = previousSiblingOrParent(currentRenderer);
</del><ins>+ searchEndRenderer = previousSiblingOrParent(*currentRenderer);
</ins><span class="cx"> } else {
</span><span class="cx"> // We are searching descendants of a previous sibling of the renderer that the
</span><span class="cx"> // counter being placed is attached to.
</span><span class="lines">@@ -270,12 +266,12 @@
</span><span class="cx"> previousSiblingProtector = currentCounter;
</span><span class="cx"> // We are no longer interested in previous siblings of the currentRenderer or their children
</span><span class="cx"> // as counters they may have attached cannot be the previous sibling of the counter we are placing.
</span><del>- currentRenderer = parentOrPseudoHostElement(currentRenderer)->renderer();
</del><ins>+ currentRenderer = parentOrPseudoHostElement(*currentRenderer)->renderer();
</ins><span class="cx"> continue;
</span><span class="cx"> }
</span><span class="cx"> } else
</span><span class="cx"> previousSiblingProtector = currentCounter;
</span><del>- currentRenderer = previousSiblingOrParent(currentRenderer);
</del><ins>+ currentRenderer = previousSiblingOrParent(*currentRenderer);
</ins><span class="cx"> continue;
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="lines">@@ -284,26 +280,17 @@
</span><span class="cx"> // performance improvement would create more code duplication than is worthwhile in my oppinion and may further
</span><span class="cx"> // impede the readability of this already complex algorithm.
</span><span class="cx"> if (previousSiblingProtector)
</span><del>- currentRenderer = previousSiblingOrParent(currentRenderer);
</del><ins>+ currentRenderer = previousSiblingOrParent(*currentRenderer);
</ins><span class="cx"> else
</span><del>- currentRenderer = previousInPreOrder(currentRenderer);
</del><ins>+ currentRenderer = previousInPreOrder(*currentRenderer);
</ins><span class="cx"> }
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static CounterNode* makeCounterNode(RenderObject* object, const AtomicString& identifier, bool alwaysCreateCounter)
</del><ins>+static CounterNode* makeCounterNode(RenderElement& renderer, const AtomicString& identifier, bool alwaysCreateCounter)
</ins><span class="cx"> {
</span><del>- ASSERT(object);
-
- // Real text nodes don't have their own style so they can't have counters.
- // We can't even look at their styles or we'll see extra resets and increments!
- if (object->isText())
- return nullptr;
-
- RenderElement* element = toRenderElement(object);
-
- if (element->hasCounterNodeMap()) {
- if (CounterMap* nodeMap = counterMaps().get(element)) {
</del><ins>+ if (renderer.hasCounterNodeMap()) {
+ if (CounterMap* nodeMap = counterMaps().get(&renderer)) {
</ins><span class="cx"> if (CounterNode* node = nodeMap->get(identifier))
</span><span class="cx"> return node;
</span><span class="cx"> }
</span><span class="lines">@@ -311,21 +298,21 @@
</span><span class="cx">
</span><span class="cx"> bool isReset = false;
</span><span class="cx"> int value = 0;
</span><del>- if (!planCounter(element, identifier, isReset, value) && !alwaysCreateCounter)
</del><ins>+ if (!planCounter(renderer, identifier, isReset, value) && !alwaysCreateCounter)
</ins><span class="cx"> return nullptr;
</span><span class="cx">
</span><span class="cx"> RefPtr<CounterNode> newParent = 0;
</span><span class="cx"> RefPtr<CounterNode> newPreviousSibling = 0;
</span><del>- RefPtr<CounterNode> newNode = CounterNode::create(element, isReset, value);
- if (findPlaceForCounter(element, identifier, isReset, newParent, newPreviousSibling))
</del><ins>+ RefPtr<CounterNode> newNode = CounterNode::create(renderer, isReset, value);
+ if (findPlaceForCounter(renderer, identifier, isReset, newParent, newPreviousSibling))
</ins><span class="cx"> newParent->insertAfter(newNode.get(), newPreviousSibling.get(), identifier);
</span><span class="cx"> CounterMap* nodeMap;
</span><del>- if (element->hasCounterNodeMap())
- nodeMap = counterMaps().get(element);
</del><ins>+ if (renderer.hasCounterNodeMap())
+ nodeMap = counterMaps().get(&renderer);
</ins><span class="cx"> else {
</span><span class="cx"> nodeMap = new CounterMap;
</span><del>- counterMaps().set(element, std::unique_ptr<CounterMap>(nodeMap));
- element->setHasCounterNodeMap(true);
</del><ins>+ counterMaps().set(&renderer, std::unique_ptr<CounterMap>(nodeMap));
+ renderer.setHasCounterNodeMap(true);
</ins><span class="cx"> }
</span><span class="cx"> nodeMap->set(identifier, newNode);
</span><span class="cx"> if (newNode->parent())
</span><span class="lines">@@ -333,9 +320,9 @@
</span><span class="cx"> // Checking if some nodes that were previously counter tree root nodes
</span><span class="cx"> // should become children of this node now.
</span><span class="cx"> CounterMaps& maps = counterMaps();
</span><del>- Element* stayWithin = parentOrPseudoHostElement(element);
</del><ins>+ Element* stayWithin = parentOrPseudoHostElement(renderer);
</ins><span class="cx"> bool skipDescendants;
</span><del>- for (RenderElement* currentRenderer = nextInPreOrder(element, stayWithin); currentRenderer; currentRenderer = nextInPreOrder(currentRenderer, stayWithin, skipDescendants)) {
</del><ins>+ for (RenderElement* currentRenderer = nextInPreOrder(renderer, stayWithin); currentRenderer; currentRenderer = nextInPreOrder(*currentRenderer, stayWithin, skipDescendants)) {
</ins><span class="cx"> skipDescendants = false;
</span><span class="cx"> if (!currentRenderer->hasCounterNodeMap())
</span><span class="cx"> continue;
</span><span class="lines">@@ -345,7 +332,7 @@
</span><span class="cx"> skipDescendants = true;
</span><span class="cx"> if (currentCounter->parent())
</span><span class="cx"> continue;
</span><del>- if (stayWithin == parentOrPseudoHostElement(currentRenderer) && currentCounter->hasResetType())
</del><ins>+ if (stayWithin == parentOrPseudoHostElement(*currentRenderer) && currentCounter->hasResetType())
</ins><span class="cx"> break;
</span><span class="cx"> newNode->insertAfter(currentCounter, newNode->lastChild(), identifier);
</span><span class="cx"> }
</span><span class="lines">@@ -399,7 +386,7 @@
</span><span class="cx"> break;
</span><span class="cx"> beforeAfterContainer = beforeAfterContainer->parent();
</span><span class="cx"> }
</span><del>- makeCounterNode(beforeAfterContainer, m_counter.identifier(), true)->addRenderer(const_cast<RenderCounter*>(this));
</del><ins>+ makeCounterNode(*beforeAfterContainer, m_counter.identifier(), true)->addRenderer(const_cast<RenderCounter*>(this));
</ins><span class="cx"> ASSERT(m_counterNode);
</span><span class="cx"> }
</span><span class="cx"> CounterNode* child = m_counterNode;
</span><span class="lines">@@ -456,17 +443,17 @@
</span><span class="cx"> for (RefPtr<CounterNode> child = node->lastDescendant(); child && child != node; child = previous) {
</span><span class="cx"> previous = child->previousInPreOrder();
</span><span class="cx"> child->parent()->removeChild(child.get());
</span><del>- ASSERT(counterMaps().get(child->owner())->get(identifier) == child);
- counterMaps().get(child->owner())->remove(identifier);
</del><ins>+ ASSERT(counterMaps().get(&child->owner())->get(identifier) == child);
+ counterMaps().get(&child->owner())->remove(identifier);
</ins><span class="cx"> }
</span><span class="cx"> if (CounterNode* parent = node->parent())
</span><span class="cx"> parent->removeChild(node);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void RenderCounter::destroyCounterNodes(RenderObject* owner)
</del><ins>+void RenderCounter::destroyCounterNodes(RenderElement& owner)
</ins><span class="cx"> {
</span><span class="cx"> CounterMaps& maps = counterMaps();
</span><del>- CounterMaps::iterator mapsIterator = maps.find(owner);
</del><ins>+ CounterMaps::iterator mapsIterator = maps.find(&owner);
</ins><span class="cx"> if (mapsIterator == maps.end())
</span><span class="cx"> return;
</span><span class="cx"> CounterMap* map = mapsIterator->value.get();
</span><span class="lines">@@ -475,12 +462,12 @@
</span><span class="cx"> destroyCounterNodeWithoutMapRemoval(it->key, it->value.get());
</span><span class="cx"> }
</span><span class="cx"> maps.remove(mapsIterator);
</span><del>- owner->setHasCounterNodeMap(false);
</del><ins>+ owner.setHasCounterNodeMap(false);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void RenderCounter::destroyCounterNode(RenderObject* owner, const AtomicString& identifier)
</del><ins>+void RenderCounter::destroyCounterNode(RenderElement& owner, const AtomicString& identifier)
</ins><span class="cx"> {
</span><del>- CounterMap* map = counterMaps().get(owner);
</del><ins>+ CounterMap* map = counterMaps().get(&owner);
</ins><span class="cx"> if (!map)
</span><span class="cx"> return;
</span><span class="cx"> CounterMap::iterator mapIterator = map->find(identifier);
</span><span class="lines">@@ -501,7 +488,7 @@
</span><span class="cx"> // map associated with a renderer, so there is no risk in leaking the map.
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void RenderCounter::rendererRemovedFromTree(RenderObject& renderer)
</del><ins>+void RenderCounter::rendererRemovedFromTree(RenderElement& renderer)
</ins><span class="cx"> {
</span><span class="cx"> if (!renderer.view().hasRenderCounters())
</span><span class="cx"> return;
</span><span class="lines">@@ -509,25 +496,26 @@
</span><span class="cx"> if (!currentRenderer)
</span><span class="cx"> currentRenderer = &renderer;
</span><span class="cx"> while (true) {
</span><del>- destroyCounterNodes(currentRenderer);
</del><ins>+ if (currentRenderer->isRenderElement())
+ destroyCounterNodes(toRenderElement(*currentRenderer));
</ins><span class="cx"> if (currentRenderer == &renderer)
</span><span class="cx"> break;
</span><span class="cx"> currentRenderer = currentRenderer->previousInPreOrder();
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static void updateCounters(RenderObject* renderer)
</del><ins>+static void updateCounters(RenderElement& renderer)
</ins><span class="cx"> {
</span><del>- const CounterDirectiveMap* directiveMap = renderer->style().counterDirectives();
</del><ins>+ const CounterDirectiveMap* directiveMap = renderer.style().counterDirectives();
</ins><span class="cx"> if (!directiveMap)
</span><span class="cx"> return;
</span><span class="cx"> CounterDirectiveMap::const_iterator end = directiveMap->end();
</span><del>- if (!renderer->hasCounterNodeMap()) {
</del><ins>+ if (!renderer.hasCounterNodeMap()) {
</ins><span class="cx"> for (CounterDirectiveMap::const_iterator it = directiveMap->begin(); it != end; ++it)
</span><span class="cx"> makeCounterNode(renderer, it->key, false);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- CounterMap* counterMap = counterMaps().get(renderer);
</del><ins>+ CounterMap* counterMap = counterMaps().get(&renderer);
</ins><span class="cx"> ASSERT(counterMap);
</span><span class="cx"> for (CounterDirectiveMap::const_iterator it = directiveMap->begin(); it != end; ++it) {
</span><span class="cx"> RefPtr<CounterNode> node = counterMap->get(it->key);
</span><span class="lines">@@ -551,25 +539,27 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void RenderCounter::rendererSubtreeAttached(RenderObject* renderer)
</del><ins>+void RenderCounter::rendererSubtreeAttached(RenderElement& renderer)
</ins><span class="cx"> {
</span><del>- if (!renderer->view().hasRenderCounters())
</del><ins>+ if (!renderer.view().hasRenderCounters())
</ins><span class="cx"> return;
</span><del>- Node* node = renderer->node();
- if (node && !node->isPseudoElement())
- node = node->parentNode();
</del><ins>+ Element* element = renderer.element();
+ if (element && !element->isPseudoElement())
+ element = element->parentElement();
</ins><span class="cx"> else
</span><del>- node = renderer->generatingNode();
- if (node && !node->renderer())
</del><ins>+ element = renderer.generatingElement();
+ if (element && !element->renderer())
</ins><span class="cx"> return; // No need to update if the parent is not attached yet
</span><del>- for (RenderObject* descendant = renderer; descendant; descendant = descendant->nextInPreOrder(renderer))
- updateCounters(descendant);
</del><ins>+ for (RenderObject* descendant = &renderer; descendant; descendant = descendant->nextInPreOrder(&renderer)) {
+ if (descendant->isRenderElement())
+ updateCounters(toRenderElement(*descendant));
+ }
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void RenderCounter::rendererStyleChanged(RenderObject* renderer, const RenderStyle* oldStyle, const RenderStyle* newStyle)
</del><ins>+void RenderCounter::rendererStyleChanged(RenderElement& renderer, const RenderStyle* oldStyle, const RenderStyle* newStyle)
</ins><span class="cx"> {
</span><del>- Node* node = renderer->generatingNode();
- if (!node || !node->renderer())
</del><ins>+ Element* element = renderer.generatingElement();
+ if (!element || !element->renderer())
</ins><span class="cx"> return; // cannot have generated content or if it can have, it will be handled during attaching
</span><span class="cx"> const CounterDirectiveMap* newCounterDirectives;
</span><span class="cx"> const CounterDirectiveMap* oldCounterDirectives;
</span><span class="lines">@@ -595,7 +585,7 @@
</span><span class="cx"> RenderCounter::destroyCounterNode(renderer, it->key);
</span><span class="cx"> }
</span><span class="cx"> } else {
</span><del>- if (renderer->hasCounterNodeMap())
</del><ins>+ if (renderer.hasCounterNodeMap())
</ins><span class="cx"> RenderCounter::destroyCounterNodes(renderer);
</span><span class="cx"> }
</span><span class="cx"> } else if (newStyle && (newCounterDirectives = newStyle->counterDirectives())) {
</span><span class="lines">@@ -623,13 +613,15 @@
</span><span class="cx">
</span><span class="cx"> AtomicString identifier(counterName);
</span><span class="cx"> for (const WebCore::RenderObject* current = root; current; current = current->nextInPreOrder()) {
</span><ins>+ if (!current->isRenderElement())
+ continue;
</ins><span class="cx"> fprintf(stderr, "%c", (current == renderer) ? '*' : ' ');
</span><span class="cx"> for (const WebCore::RenderObject* parent = current; parent && parent != root; parent = parent->parent())
</span><span class="cx"> fprintf(stderr, " ");
</span><span class="cx"> fprintf(stderr, "%p N:%p P:%p PS:%p NS:%p C:%p\n",
</span><span class="cx"> current, current->node(), current->parent(), current->previousSibling(),
</span><del>- current->nextSibling(), current->hasCounterNodeMap() ?
- counterName ? WebCore::counterMaps().get(current)->get(identifier) : (WebCore::CounterNode*)1 : (WebCore::CounterNode*)0);
</del><ins>+ current->nextSibling(), toRenderElement(current)->hasCounterNodeMap() ?
+ counterName ? WebCore::counterMaps().get(toRenderElement(current))->get(identifier) : (WebCore::CounterNode*)1 : (WebCore::CounterNode*)0);
</ins><span class="cx"> }
</span><span class="cx"> fflush(stderr);
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderCounterh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderCounter.h (172729 => 172730)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderCounter.h 2014-08-18 22:03:24 UTC (rev 172729)
+++ trunk/Source/WebCore/rendering/RenderCounter.h 2014-08-18 22:16:47 UTC (rev 172730)
</span><span class="lines">@@ -34,11 +34,11 @@
</span><span class="cx"> RenderCounter(Document&, const CounterContent&);
</span><span class="cx"> virtual ~RenderCounter();
</span><span class="cx">
</span><del>- static void destroyCounterNodes(RenderObject*);
- static void destroyCounterNode(RenderObject*, const AtomicString& identifier);
- static void rendererSubtreeAttached(RenderObject*);
- static void rendererRemovedFromTree(RenderObject&);
- static void rendererStyleChanged(RenderObject*, const RenderStyle* oldStyle, const RenderStyle* newStyle);
</del><ins>+ static void destroyCounterNodes(RenderElement&);
+ static void destroyCounterNode(RenderElement&, const AtomicString& identifier);
+ static void rendererSubtreeAttached(RenderElement&);
+ static void rendererRemovedFromTree(RenderElement&);
+ static void rendererStyleChanged(RenderElement&, const RenderStyle* oldStyle, const RenderStyle* newStyle);
</ins><span class="cx">
</span><span class="cx"> void updateCounter();
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderElementcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderElement.cpp (172729 => 172730)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderElement.cpp 2014-08-18 22:03:24 UTC (rev 172729)
+++ trunk/Source/WebCore/rendering/RenderElement.cpp 2014-08-18 22:16:47 UTC (rev 172730)
</span><span class="lines">@@ -85,6 +85,7 @@
</span><span class="cx"> , m_renderInlineAlwaysCreatesLineBoxes(false)
</span><span class="cx"> , m_renderBoxNeedsLazyRepaint(false)
</span><span class="cx"> , m_hasPausedImageAnimations(false)
</span><ins>+ , m_hasCounterNodeMap(false)
</ins><span class="cx"> , m_firstChild(nullptr)
</span><span class="cx"> , m_lastChild(nullptr)
</span><span class="cx"> , m_style(WTF::move(style))
</span><span class="lines">@@ -568,7 +569,8 @@
</span><span class="cx"> if (!documentBeingDestroyed()) {
</span><span class="cx"> if (notifyChildren == NotifyChildren)
</span><span class="cx"> newChild->insertedIntoTree();
</span><del>- RenderCounter::rendererSubtreeAttached(newChild);
</del><ins>+ if (newChild->isRenderElement())
+ RenderCounter::rendererSubtreeAttached(toRenderElement(*newChild));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> newChild->setNeedsLayoutAndPrefWidthsRecalc();
</span><span class="lines">@@ -636,8 +638,8 @@
</span><span class="cx">
</span><span class="cx"> // rendererRemovedFromTree walks the whole subtree. We can improve performance
</span><span class="cx"> // by skipping this step when destroying the entire tree.
</span><del>- if (!documentBeingDestroyed())
- RenderCounter::rendererRemovedFromTree(oldChild);
</del><ins>+ if (!documentBeingDestroyed() && oldChild.isRenderElement())
+ RenderCounter::rendererRemovedFromTree(toRenderElement(oldChild));
</ins><span class="cx">
</span><span class="cx"> if (AXObjectCache* cache = document().existingAXObjectCache())
</span><span class="cx"> cache->childrenChanged(this);
</span><span class="lines">@@ -920,7 +922,7 @@
</span><span class="cx"> return;
</span><span class="cx">
</span><span class="cx"> if (diff == StyleDifferenceLayout || diff == StyleDifferenceSimplifiedLayout) {
</span><del>- RenderCounter::rendererStyleChanged(this, oldStyle, &m_style.get());
</del><ins>+ RenderCounter::rendererStyleChanged(*this, oldStyle, &m_style.get());
</ins><span class="cx">
</span><span class="cx"> // If the object already needs layout, then setNeedsLayout won't do
</span><span class="cx"> // any work. But if the containing block has changed, then we may need
</span><span class="lines">@@ -1007,6 +1009,9 @@
</span><span class="cx">
</span><span class="cx"> destroyLeftoverChildren();
</span><span class="cx">
</span><ins>+ if (hasCounterNodeMap())
+ RenderCounter::destroyCounterNodes(*this);
+
</ins><span class="cx"> RenderObject::willBeDestroyed();
</span><span class="cx">
</span><span class="cx"> #if !ASSERT_DISABLED
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderElementh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderElement.h (172729 => 172730)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderElement.h 2014-08-18 22:03:24 UTC (rev 172729)
+++ trunk/Source/WebCore/rendering/RenderElement.h 2014-08-18 22:16:47 UTC (rev 172730)
</span><span class="lines">@@ -159,6 +159,9 @@
</span><span class="cx"> void setRenderBoxNeedsLazyRepaint(bool b) { m_renderBoxNeedsLazyRepaint = b; }
</span><span class="cx"> bool renderBoxNeedsLazyRepaint() const { return m_renderBoxNeedsLazyRepaint; }
</span><span class="cx">
</span><ins>+ bool hasCounterNodeMap() const { return m_hasCounterNodeMap; }
+ void setHasCounterNodeMap(bool f) { m_hasCounterNodeMap = f; }
+
</ins><span class="cx"> protected:
</span><span class="cx"> enum BaseTypeFlags {
</span><span class="cx"> RenderLayerModelObjectFlag = 1 << 0,
</span><span class="lines">@@ -231,6 +234,7 @@
</span><span class="cx"> bool m_renderInlineAlwaysCreatesLineBoxes : 1;
</span><span class="cx"> bool m_renderBoxNeedsLazyRepaint : 1;
</span><span class="cx"> bool m_hasPausedImageAnimations : 1;
</span><ins>+ bool m_hasCounterNodeMap : 1;
</ins><span class="cx">
</span><span class="cx"> RenderObject* m_firstChild;
</span><span class="cx"> RenderObject* m_lastChild;
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderObjectcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderObject.cpp (172729 => 172730)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderObject.cpp 2014-08-18 22:03:24 UTC (rev 172729)
+++ trunk/Source/WebCore/rendering/RenderObject.cpp 2014-08-18 22:16:47 UTC (rev 172730)
</span><span class="lines">@@ -1941,14 +1941,6 @@
</span><span class="cx"> if (AXObjectCache* cache = document().existingAXObjectCache())
</span><span class="cx"> cache->remove(this);
</span><span class="cx">
</span><del>- // If this renderer had a parent, remove should have destroyed any counters
- // attached to this renderer and marked the affected other counters for
- // reevaluation. This apparently redundant check is here for the case when
- // this renderer had no parent at the time remove() was called.
-
- if (hasCounterNodeMap())
- RenderCounter::destroyCounterNodes(this);
-
</del><span class="cx"> // FIXME: Would like to do this in RenderBoxModelObject, but the timing is so complicated that this can't easily
</span><span class="cx"> // be moved into RenderBoxModelObject::destroy.
</span><span class="cx"> if (hasLayer()) {
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderObjecth"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderObject.h (172729 => 172730)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderObject.h 2014-08-18 22:03:24 UTC (rev 172729)
+++ trunk/Source/WebCore/rendering/RenderObject.h 2014-08-18 22:16:47 UTC (rev 172730)
</span><span class="lines">@@ -390,8 +390,6 @@
</span><span class="cx"> static inline bool isAfterContent(const RenderObject* obj) { return obj && obj->isAfterContent(); }
</span><span class="cx"> static inline bool isBeforeOrAfterContent(const RenderObject* obj) { return obj && obj->isBeforeOrAfterContent(); }
</span><span class="cx">
</span><del>- bool hasCounterNodeMap() const { return m_bitfields.hasCounterNodeMap(); }
- void setHasCounterNodeMap(bool hasCounterNodeMap) { m_bitfields.setHasCounterNodeMap(hasCounterNodeMap); }
</del><span class="cx"> bool everHadLayout() const { return m_bitfields.everHadLayout(); }
</span><span class="cx">
</span><span class="cx"> bool childrenInline() const { return m_bitfields.childrenInline(); }
</span><span class="lines">@@ -961,7 +959,6 @@
</span><span class="cx"> , m_hasOverflowClip(false)
</span><span class="cx"> , m_hasTransform(false)
</span><span class="cx"> , m_hasReflection(false)
</span><del>- , m_hasCounterNodeMap(false)
</del><span class="cx"> , m_everHadLayout(false)
</span><span class="cx"> , m_childrenInline(false)
</span><span class="cx"> , m_positionedState(IsStaticallyPositioned)
</span><span class="lines">@@ -971,7 +968,7 @@
</span><span class="cx"> {
</span><span class="cx"> }
</span><span class="cx">
</span><del>- // 32 bits have been used here. There are no bits available.
</del><ins>+ // 31 bits have been used here. There is one bit available.
</ins><span class="cx"> ADD_BOOLEAN_BITFIELD(needsLayout, NeedsLayout);
</span><span class="cx"> ADD_BOOLEAN_BITFIELD(needsPositionedMovementLayout, NeedsPositionedMovementLayout);
</span><span class="cx"> ADD_BOOLEAN_BITFIELD(normalChildNeedsLayout, NormalChildNeedsLayout);
</span><span class="lines">@@ -994,7 +991,6 @@
</span><span class="cx"> ADD_BOOLEAN_BITFIELD(hasTransform, HasTransform);
</span><span class="cx"> ADD_BOOLEAN_BITFIELD(hasReflection, HasReflection);
</span><span class="cx">
</span><del>- ADD_BOOLEAN_BITFIELD(hasCounterNodeMap, HasCounterNodeMap);
</del><span class="cx"> ADD_BOOLEAN_BITFIELD(everHadLayout, EverHadLayout);
</span><span class="cx">
</span><span class="cx"> // from RenderBlock
</span></span></pre>
</div>
</div>
</body>
</html>