Rename/move counter rendering code to layout.

Source/core/layout/LayoutCounter.cpp

 /**
  * Copyright (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #include "config.h"
-#include "core/rendering/RenderCounter.h"
+#include "core/layout/LayoutCounter.h"
 
 #include "core/HTMLNames.h"
 #include "core/dom/Element.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/html/HTMLOListElement.h"
-#include "core/rendering/CounterNode.h"
+#include "core/layout/CounterNode.h"
 #include "core/rendering/RenderListItem.h"
 #include "core/rendering/RenderListMarker.h"
 #include "core/rendering/RenderView.h"
 #include "core/rendering/style/RenderStyle.h"
 #include "wtf/StdLibExtras.h"
 
 #ifndef NDEBUG
 #include <stdio.h>
 #endif
 
@@ skipping 227 matching lines @@
                 if (previousSiblingProtector) {
                     // Since we had a suitable previous counter before, we should only consider this one as our
                     // previousSibling if it is a reset counter and hence the current previousSibling is its child.
                     if (currentCounter->actsAsReset()) {
                         previousSiblingProtector = currentCounter;
                         // We are no longer interested in previous siblings of the currentRenderer or their children
                         // as counters they may have attached cannot be the previous sibling of the counter we are placing.
                         currentRenderer = parentElement(*currentRenderer)->renderer();
                         continue;
                     }
-                } else
+                } else {
                     previousSiblingProtector = currentCounter;
+                }
                 currentRenderer = previousSiblingOrParent(*currentRenderer);
                 continue;
             }
         }
         // This function is designed so that the same test is not done twice in an iteration, except for this one
         // which may be done twice in some cases. Rearranging the decision points though, to accommodate this
         // performance improvement would create more code duplication than is worthwhile in my oppinion and may further
         // impede the readability of this already complex algorithm.
         if (previousSiblingProtector)
             currentRenderer = previousSiblingOrParent(*currentRenderer);
@@ skipping 16 matching lines @@
     int value = 0;
     if (!planCounter(object, identifier, isReset, value) && !alwaysCreateCounter)
         return 0;
 
     RefPtr<CounterNode> newParent = nullptr;
     RefPtr<CounterNode> newPreviousSibling = nullptr;
     RefPtr<CounterNode> newNode = CounterNode::create(object, isReset, value);
     if (findPlaceForCounter(object, identifier, isReset, newParent, newPreviousSibling))
         newParent->insertAfter(newNode.get(), newPreviousSibling.get(), identifier);
     CounterMap* nodeMap;
-    if (object.hasCounterNodeMap())
+    if (object.hasCounterNodeMap()) {
         nodeMap = counterMaps().get(&object);
-    else {
+    } else {
         nodeMap = new CounterMap;
         counterMaps().set(&object, adoptPtr(nodeMap));
         object.setHasCounterNodeMap(true);
     }
     nodeMap->set(identifier, newNode);
     if (newNode->parent())
         return newNode.get();
     // Checking if some nodes that were previously counter tree root nodes
     // should become children of this node now.
     CounterMaps& maps = counterMaps();
     Element* stayWithin = parentElement(object);
     bool skipDescendants;
     for (RenderObject* currentRenderer = nextInPreOrder(object, stayWithin); currentRenderer; currentRenderer = nextInPreOrder(*currentRenderer, stayWithin, skipDescendants)) {
         skipDescendants = false;
         if (!currentRenderer->hasCounterNodeMap())
             continue;
         CounterNode* currentCounter = maps.get(currentRenderer)->get(identifier);
         if (!currentCounter)
             continue;
         skipDescendants = true;
         if (currentCounter->parent())
             continue;
         if (stayWithin == parentElement(*currentRenderer) && currentCounter->hasResetType())
             break;
         newNode->insertAfter(currentCounter, newNode->lastChild(), identifier);
     }
     return newNode.get();
 }
 
-RenderCounter::RenderCounter(Document* node, const CounterContent& counter)
+LayoutCounter::LayoutCounter(Document* node, const CounterContent& counter)
     : RenderText(node, StringImpl::empty())
     , m_counter(counter)
     , m_counterNode(0)
     , m_nextForSameCounter(0)
 {
-    view()->addRenderCounter();
+    view()->addLayoutCounter();
 }
 
-RenderCounter::~RenderCounter()
+LayoutCounter::~LayoutCounter()
 {
 }
 
-void RenderCounter::destroy()
+void LayoutCounter::destroy()
 {
     if (m_counterNode) {
         m_counterNode->removeRenderer(this);
         ASSERT(!m_counterNode);
     }
     RenderText::destroy();
 }
 
-void RenderCounter::willBeDestroyed()
+void LayoutCounter::willBeDestroyed()
 {
     if (view())
-        view()->removeRenderCounter();
+        view()->removeLayoutCounter();
     RenderText::willBeDestroyed();
 }
 
-const char* RenderCounter::renderName() const
+const char* LayoutCounter::renderName() const
 {
-    return "RenderCounter";
+    return "LayoutCounter";
 }
 
-PassRefPtr<StringImpl> RenderCounter::originalText() const
+PassRefPtr<StringImpl> LayoutCounter::originalText() const
 {
     if (!m_counterNode) {
         RenderObject* beforeAfterContainer = parent();
         while (true) {
             if (!beforeAfterContainer)
                 return nullptr;
             if (!beforeAfterContainer->isAnonymous() && !beforeAfterContainer->isPseudoElement())
-                return nullptr; // RenderCounters are restricted to before and after pseudo elements
+                return nullptr; // LayoutCounters are restricted to before and after pseudo elements
             PseudoId containerStyle = beforeAfterContainer->style()->styleType();
             if ((containerStyle == BEFORE) || (containerStyle == AFTER))
                 break;
             beforeAfterContainer = beforeAfterContainer->parent();
         }
-        makeCounterNode(*beforeAfterContainer, m_counter.identifier(), true)->addRenderer(const_cast<RenderCounter*>(this));
+        makeCounterNode(*beforeAfterContainer, m_counter.identifier(), true)->addRenderer(const_cast<LayoutCounter*>(this));
         ASSERT(m_counterNode);
     }
     CounterNode* child = m_counterNode;
     int value = child->actsAsReset() ? child->value() : child->countInParent();
 
     String text = listMarkerText(m_counter.listStyle(), value);
 
     if (!m_counter.separator().isNull()) {
         if (!child->actsAsReset())
             child = child->parent();
         while (CounterNode* parent = child->parent()) {
             text = listMarkerText(m_counter.listStyle(), child->countInParent())
                 + m_counter.separator() + text;
             child = parent;
         }
     }
 
     return text.impl();
 }
 
-void RenderCounter::updateCounter()
+void LayoutCounter::updateCounter()
 {
     setText(originalText());
 }
 
-void RenderCounter::invalidate()
+void LayoutCounter::invalidate()
 {
     m_counterNode->removeRenderer(this);
     ASSERT(!m_counterNode);
     if (documentBeingDestroyed())
         return;
     setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation();
 }
 
 static void destroyCounterNodeWithoutMapRemoval(const AtomicString& identifier, CounterNode* node)
 {
     CounterNode* previous;
     for (RefPtr<CounterNode> child = node->lastDescendant(); child && child != node; child = previous) {
         previous = child->previousInPreOrder();
         child->parent()->removeChild(child.get());
         ASSERT(counterMaps().get(&child->owner())->get(identifier) == child);
         counterMaps().get(&child->owner())->remove(identifier);
     }
     if (CounterNode* parent = node->parent())
         parent->removeChild(node);
 }
 
-void RenderCounter::destroyCounterNodes(RenderObject& owner)
+void LayoutCounter::destroyCounterNodes(RenderObject& owner)
 {
     CounterMaps& maps = counterMaps();
     CounterMaps::iterator mapsIterator = maps.find(&owner);
     if (mapsIterator == maps.end())
         return;
     CounterMap* map = mapsIterator->value.get();
     CounterMap::const_iterator end = map->end();
     for (CounterMap::const_iterator it = map->begin(); it != end; ++it) {
         destroyCounterNodeWithoutMapRemoval(it->key, it->value.get());
     }
     maps.remove(mapsIterator);
     owner.setHasCounterNodeMap(false);
 }
 
-void RenderCounter::destroyCounterNode(RenderObject& owner, const AtomicString& identifier)
+void LayoutCounter::destroyCounterNode(RenderObject& owner, const AtomicString& identifier)
 {
     CounterMap* map = counterMaps().get(&owner);
     if (!map)
         return;
     CounterMap::iterator mapIterator = map->find(identifier);
     if (mapIterator == map->end())
         return;
     destroyCounterNodeWithoutMapRemoval(identifier, mapIterator->value.get());
     map->remove(mapIterator);
     // We do not delete "map" here even if empty because we expect to reuse
     // it soon. In order for a renderer to lose all its counters permanently,
     // a style change for the renderer involving removal of all counter
-    // directives must occur, in which case, RenderCounter::destroyCounterNodes()
+    // directives must occur, in which case, LayoutCounter::destroyCounterNodes()
     // must be called.
     // The destruction of the Renderer (possibly caused by the removal of its
     // associated DOM node) is the other case that leads to the permanent
     // destruction of all counters attached to a Renderer. In this case
-    // RenderCounter::destroyCounterNodes() must be and is now called, too.
-    // RenderCounter::destroyCounterNodes() handles destruction of the counter
+    // LayoutCounter::destroyCounterNodes() must be and is now called, too.
+    // LayoutCounter::destroyCounterNodes() handles destruction of the counter
     // map associated with a renderer, so there is no risk in leaking the map.
 }
 
-void RenderCounter::rendererRemovedFromTree(RenderObject* renderer)
+void LayoutCounter::rendererRemovedFromTree(RenderObject* renderer)
 {
     ASSERT(renderer->view());
-    if (!renderer->view()->hasRenderCounters())
+    if (!renderer->view()->hasLayoutCounters())
         return;
     RenderObject* currentRenderer = renderer->lastLeafChild();
     if (!currentRenderer)
         currentRenderer = renderer;
     while (true) {
         destroyCounterNodes(*currentRenderer);
         if (currentRenderer == renderer)
             break;
         currentRenderer = currentRenderer->previousInPreOrder();
     }
@@ skipping 28 matching lines @@
         CounterNode* parent = node->parent();
         if (newParent == parent && newPreviousSibling == node->previousSibling())
             continue;
         if (parent)
             parent->removeChild(node.get());
         if (newParent)
             newParent->insertAfter(node.get(), newPreviousSibling.get(), it->key);
     }
 }
 
-void RenderCounter::rendererSubtreeAttached(RenderObject* renderer)
+void LayoutCounter::rendererSubtreeAttached(RenderObject* renderer)
 {
     ASSERT(renderer->view());
-    if (!renderer->view()->hasRenderCounters())
+    if (!renderer->view()->hasLayoutCounters())
         return;
     Node* node = renderer->node();
     if (node)
         node = node->parentNode();
     else
         node = renderer->generatingNode();
     if (node && node->needsAttach())
         return; // No need to update if the parent is not attached yet
     for (RenderObject* descendant = renderer; descendant; descendant = descendant->nextInPreOrder(renderer))
         updateCounters(*descendant);
 }
 
-void RenderCounter::rendererStyleChanged(RenderObject& renderer, const RenderStyle* oldStyle, const RenderStyle* newStyle)
+void LayoutCounter::rendererStyleChanged(RenderObject& renderer, const RenderStyle* oldStyle, const RenderStyle* newStyle)
 {
     Node* node = renderer.generatingNode();
     if (!node || node->needsAttach())
         return; // cannot have generated content or if it can have, it will be handled during attaching
     const CounterDirectiveMap* oldCounterDirectives = oldStyle ? oldStyle->counterDirectives() : 0;
     const CounterDirectiveMap* newCounterDirectives = newStyle ? newStyle->counterDirectives() : 0;
     if (oldCounterDirectives) {
         if (newCounterDirectives) {
             CounterDirectiveMap::const_iterator newMapEnd = newCounterDirectives->end();
             CounterDirectiveMap::const_iterator oldMapEnd = oldCounterDirectives->end();
             for (CounterDirectiveMap::const_iterator it = newCounterDirectives->begin(); it != newMapEnd; ++it) {
                 CounterDirectiveMap::const_iterator oldMapIt = oldCounterDirectives->find(it->key);
                 if (oldMapIt != oldMapEnd) {
                     if (oldMapIt->value == it->value)
                         continue;
-                    RenderCounter::destroyCounterNode(renderer, it->key);
+                    LayoutCounter::destroyCounterNode(renderer, it->key);
                 }
                 // We must create this node here, because the changed node may be a node with no display such as
                 // as those created by the increment or reset directives and the re-layout that will happen will
                 // not catch the change if the node had no children.
                 makeCounterNode(renderer, it->key, false);
             }
             // Destroying old counters that do not exist in the new counterDirective map.
             for (CounterDirectiveMap::const_iterator it = oldCounterDirectives->begin(); it !=oldMapEnd; ++it) {
                 if (!newCounterDirectives->contains(it->key))
-                    RenderCounter::destroyCounterNode(renderer, it->key);
+                    LayoutCounter::destroyCounterNode(renderer, it->key);
             }
         } else {
             if (renderer.hasCounterNodeMap())
-                RenderCounter::destroyCounterNodes(renderer);
+                LayoutCounter::destroyCounterNodes(renderer);
         }
     } else if (newCounterDirectives) {
         CounterDirectiveMap::const_iterator newMapEnd = newCounterDirectives->end();
         for (CounterDirectiveMap::const_iterator it = newCounterDirectives->begin(); it != newMapEnd; ++it) {
             // We must create this node here, because the added node may be a node with no display such as
             // as those created by the increment or reset directives and the re-layout that will happen will
             // not catch the change if the node had no children.
             makeCounterNode(renderer, it->key, false);
         }
     }
@@ skipping 18 matching lines @@
             fprintf(stderr, "    ");
         fprintf(stderr, "%p N:%p P:%p PS:%p NS:%p C:%p\n",
             current, current->node(), current->parent(), current->previousSibling(),
             current->nextSibling(), current->hasCounterNodeMap() ?
             counterName ? blink::counterMaps().get(current)->get(identifier) : (blink::CounterNode*)1 : (blink::CounterNode*)0);
     }
     fflush(stderr);
 }
 
 #endif // NDEBUG