Merge 68819

WebCore/rendering/RenderCounter.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,
@@ skipping 17 matching lines @@
 #include "HTMLOListElement.h"
 #include "RenderListItem.h"
 #include "RenderListMarker.h"
 #include "RenderStyle.h"
 #include <wtf/StdLibExtras.h>
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
-typedef HashMap<RefPtr<AtomicStringImpl>, CounterNode*> CounterMap;
+typedef HashMap<RefPtr<AtomicStringImpl>, RefPtr<CounterNode> > CounterMap;
 typedef HashMap<const RenderObject*, CounterMap*> CounterMaps;
 
 static CounterNode* makeCounterNode(RenderObject*, const AtomicString& identifier, bool alwaysCreateCounter);
 
 static CounterMaps& counterMaps()
 {
     DEFINE_STATIC_LOCAL(CounterMaps, staticCounterMaps, ());
     return staticCounterMaps;
 }
 
@@ skipping 179 matching lines @@
         else
             currentRenderer = currentRenderer->previousInPreOrder();
     }
     return false;
 }
 
 static CounterNode* makeCounterNode(RenderObject* object, const AtomicString& identifier, bool alwaysCreateCounter)
 {
     ASSERT(object);
 
-    if (object->m_hasCounterNodeMap)
-        if (CounterMap* nodeMap = counterMaps().get(object))
-            if (CounterNode* node = nodeMap->get(identifier.impl()))
+    if (object->m_hasCounterNodeMap) {
+        if (CounterMap* nodeMap = counterMaps().get(object)) {
+            if (CounterNode* node = nodeMap->get(identifier.impl()).get())
                 return node;
+        }
+    }
 
     bool isReset = false;
     int value = 0;
     if (!planCounter(object, identifier, isReset, value) && !alwaysCreateCounter)
         return 0;
 
     CounterNode* newParent = 0;
     CounterNode* newPreviousSibling = 0;
-    CounterNode* newNode = new CounterNode(object, isReset, value);
+    RefPtr<CounterNode> newNode = CounterNode::create(object, isReset, value);
     if (findPlaceForCounter(object, identifier, isReset, newParent, newPreviousSibling))
-        newParent->insertAfter(newNode, newPreviousSibling, identifier);
+        newParent->insertAfter(newNode.get(), newPreviousSibling, identifier);
     CounterMap* nodeMap;
     if (object->m_hasCounterNodeMap)
         nodeMap = counterMaps().get(object);
     else {
         nodeMap = new CounterMap;
         counterMaps().set(object, nodeMap);
         object->m_hasCounterNodeMap = true;
     }
     nodeMap->set(identifier.impl(), newNode);
     if (newNode->parent() || !object->nextInPreOrder(object->parent()))
-        return newNode;
+        return newNode.get();
     // Checking if some nodes that were previously counter tree root nodes
     // should become children of this node now.
     CounterMaps& maps = counterMaps();
     RenderObject* stayWithin = object->parent();
     for (RenderObject* currentRenderer = object->nextInPreOrder(stayWithin); currentRenderer; currentRenderer = currentRenderer->nextInPreOrder(stayWithin)) {
         if (!currentRenderer->m_hasCounterNodeMap)
             continue;
-        CounterNode* currentCounter = maps.get(currentRenderer)->get(identifier.impl());
+        CounterNode* currentCounter = maps.get(currentRenderer)->get(identifier.impl()).get();
         if (!currentCounter)
             continue;
         if (currentCounter->parent()) {
             ASSERT(newNode->firstChild());
             if (currentRenderer->lastChild())
                 currentRenderer = currentRenderer->lastChild();
             continue;
         }
         if (stayWithin != currentRenderer->parent() || !currentCounter->hasResetType())
             newNode->insertAfter(currentCounter, newNode->lastChild(), identifier);
         if (currentRenderer->lastChild())
             currentRenderer = currentRenderer->lastChild();
     }
-    return newNode;
+    return newNode.get();
 }
 
 RenderCounter::RenderCounter(Document* node, const CounterContent& counter)
     : RenderText(node, StringImpl::empty())
     , m_counter(counter)
     , m_counterNode(0)
 {
 }
 
 const char* RenderCounter::renderName() const
@@ skipping 42 matching lines @@
 {
     if (m_counter.identifier() != identifier)
         return;
     m_counterNode = 0;
     setNeedsLayoutAndPrefWidthsRecalc();
 }
 
 static void destroyCounterNodeWithoutMapRemoval(const AtomicString& identifier, CounterNode* node)
 {
     CounterNode* previous;
-    for (CounterNode* child = node->lastDescendant(); child && child != node; child = previous) {
+    for (RefPtr<CounterNode> child = node->lastDescendant(); child && child != node; child = previous) {
         previous = child->previousInPreOrder();
-        child->parent()->removeChild(child, identifier);
+        child->parent()->removeChild(child.get(), identifier);
         ASSERT(counterMaps().get(child->renderer())->get(identifier.impl()) == child);
         counterMaps().get(child->renderer())->remove(identifier.impl());
         if (!child->renderer()->documentBeingDestroyed()) {
             RenderObjectChildList* children = child->renderer()->virtualChildren();
             if (children)
                 children->invalidateCounters(child->renderer(), identifier);
         }
-        delete child;
     }
     RenderObject* renderer = node->renderer();
     if (!renderer->documentBeingDestroyed()) {
         if (RenderObjectChildList* children = renderer->virtualChildren())
             children->invalidateCounters(renderer, identifier);
     }
     if (CounterNode* parent = node->parent())
         parent->removeChild(node, identifier);
-    delete node;
 }
 
 void RenderCounter::destroyCounterNodes(RenderObject* renderer)
 {
     CounterMaps& maps = counterMaps();
     CounterMaps::iterator mapsIterator = maps.find(renderer);
     if (mapsIterator == maps.end())
         return;
     CounterMap* map = mapsIterator->second;
     CounterMap::const_iterator end = map->end();
     for (CounterMap::const_iterator it = map->begin(); it != end; ++it) {
         AtomicString identifier(it->first.get());
-        destroyCounterNodeWithoutMapRemoval(identifier, it->second);
+        destroyCounterNodeWithoutMapRemoval(identifier, it->second.get());
     }
     maps.remove(mapsIterator);
     delete map;
     renderer->m_hasCounterNodeMap = false;
 }
 
 void RenderCounter::destroyCounterNode(RenderObject* renderer, const AtomicString& identifier)
 {
     CounterMap* map = counterMaps().get(renderer);
     if (!map)
         return;
     CounterMap::iterator mapIterator = map->find(identifier.impl());
     if (mapIterator == map->end())
         return;
-    destroyCounterNodeWithoutMapRemoval(identifier, mapIterator->second);
+    destroyCounterNodeWithoutMapRemoval(identifier, mapIterator->second.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()
     // 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
     // map associated with a renderer, so there is no risk in leaking the map.
 }
 
 static void updateCounters(RenderObject* renderer)
 {
     ASSERT(renderer->style());
     const CounterDirectiveMap* directiveMap = renderer->style()->counterDirectives();
     if (!directiveMap)
         return;
     CounterDirectiveMap::const_iterator end = directiveMap->end();
     if (!renderer->m_hasCounterNodeMap) {
         for (CounterDirectiveMap::const_iterator it = directiveMap->begin(); it != end; ++it)
             makeCounterNode(renderer, AtomicString(it->first.get()), false);
         return;
     }
     CounterMap* counterMap = counterMaps().get(renderer);
     ASSERT(counterMap);
     for (CounterDirectiveMap::const_iterator it = directiveMap->begin(); it != end; ++it) {
-        CounterNode* node = counterMap->get(it->first.get());
+        RefPtr<CounterNode> node = counterMap->get(it->first.get());
         if (!node) {
             makeCounterNode(renderer, AtomicString(it->first.get()), false);
             continue;
         }
         CounterNode* newParent = 0;
         CounterNode* newPreviousSibling;
+        
         findPlaceForCounter(renderer, AtomicString(it->first.get()), node->hasResetType(), newParent, newPreviousSibling);
+        if (node != counterMap->get(it->first.get()))
+            continue;
         CounterNode* parent = node->parent();
         if (newParent == parent && newPreviousSibling == node->previousSibling())
             continue;
         if (parent)
-            parent->removeChild(node, it->first.get());
+            parent->removeChild(node.get(), it->first.get());
         if (newParent)
-            newParent->insertAfter(node, newPreviousSibling, it->first.get());
+            newParent->insertAfter(node.get(), newPreviousSibling, it->first.get());
     }
 }
 
 void RenderCounter::rendererSubtreeAttached(RenderObject* renderer)
 {
     for (RenderObject* descendant = renderer; descendant; descendant = descendant->nextInPreOrder(renderer))
         updateCounters(descendant);
 }
 
 void RenderCounter::rendererStyleChanged(RenderObject* renderer, const RenderStyle* oldStyle, const RenderStyle* newStyle)
@@ skipping 30 matching lines @@
         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->first.get(), false);
         }
     }
 }
 
 } // namespace WebCore