Oilpan: cleanup based on review comments after removal of TreeShared.

Source/core/svg/SVGElement.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2008 Rob Buis <buis@kde.org>
  * Copyright (C) 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Alp Toker <alp@atoker.com>
  * Copyright (C) 2009 Cameron McCormack <cam@mcc.id.au>
  *
  * 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
@@ skipping 514 matching lines @@
 {
     // This function is provided for use by SVGAnimatedProperty to avoid
     // global inclusion of core/dom/Document.h in SVG code.
     return document().accessSVGExtensions();
 }
 
 void SVGElement::mapInstanceToElement(SVGElementInstance* instance)
 {
     ASSERT(instance);
 
-    HashSet<SVGElement*>& instances = ensureSVGRareData()->elementInstances();
+    WillBeHeapHashSet<RawPtrWillBeWeakMember<SVGElement> >& instances = ensureSVGRareData()->elementInstances();
     ASSERT(!instances.contains(instance->shadowTreeElement()));
 
     instances.add(instance->shadowTreeElement());
 }
 
 void SVGElement::removeInstanceMapping(SVGElementInstance* instance)
 {
     ASSERT(instance);
     ASSERT(hasSVGRareData());
 
     if (!instance->shadowTreeElement())
         return;
 
-    HashSet<SVGElement*>& instances = svgRareData()->elementInstances();
+    WillBeHeapHashSet<RawPtrWillBeWeakMember<SVGElement> >& instances = svgRareData()->elementInstances();

[haraken, 2014/05/07 12:50:20]

Shall we typedef this? We have a lot of 
WillBeHeapHashSet<RawPtrWillBeWeakMember<SVGElement> > in this CL.

[Mads Ager (chromium), 2014/05/08 09:08:59]

The issue is that this type is used all over the place and there seems to be no
good place for the typedef...

[haraken, 2014/05/08 09:15:41]

Probably you can define it in SVGElement.h, since the call sites of
WillBeHeapHashSet<RawPtrWillBeWeakMember<SVGElement> > should include
SVGElement.h. If no, I'm OK with not having the typedef.

     ASSERT(instances.contains(instance->shadowTreeElement()));
 
     instances.remove(instance->shadowTreeElement());
 }
 
-const HashSet<SVGElement*>& SVGElement::instancesForElement() const
+static WillBeHeapHashSet<RawPtrWillBeWeakMember<SVGElement> >& emptyInstances()
 {
-    if (!hasSVGRareData()) {
-        DEFINE_STATIC_LOCAL(HashSet<SVGElement*>, emptyInstances, ());
-        return emptyInstances;
-    }
+#if ENABLE(OILPAN)
+    DEFINE_STATIC_LOCAL(Persistent<HeapHashSet<WeakMember<SVGElement> > >, emptyInstances, (new HeapHashSet<WeakMember<SVGElement> >));
+    return *emptyInstances;
+#else
+    DEFINE_STATIC_LOCAL(HashSet<RawPtr<SVGElement> >, emptyInstances, ());
+    return emptyInstances;
+#endif
+}
+
+const WillBeHeapHashSet<RawPtrWillBeWeakMember<SVGElement> >& SVGElement::instancesForElement() const
+{
+    if (!hasSVGRareData())
+        return emptyInstances();
     return svgRareData()->elementInstances();

[haraken, 2014/05/07 12:50:20]

Probably not related to your CL, but I'm not quite sure how this works.

If we don't have SVGRareData, we return a hash set from emptyInstances(). Then
we add things to the hash set. At some point, SVGRareData is created, then we
return a hash set from the SVGRareData. Now we have two hash sets involved.
Won't it cause an issue?

[Mads Ager (chromium), 2014/05/08 09:08:59]

Yeah, unrelated to my change. When you collect element instance you always
create a new set, so the empty set here should never be updated. In any case, if
there is an issue here it is unrelated to this change. 

 }
 
 bool SVGElement::getBoundingBox(FloatRect& rect)
 {
     if (!isSVGGraphicsElement())
         return false;
 
     rect = toSVGGraphicsElement(this)->getBBox();
     return true;
 }
@@ skipping 206 matching lines @@
 
 bool SVGElement::haveLoadedRequiredResources()
 {
     for (SVGElement* child = Traversal<SVGElement>::firstChild(*this); child; child = Traversal<SVGElement>::nextSibling(*child)) {
         if (!child->haveLoadedRequiredResources())
             return false;
     }
     return true;
 }
 
-static inline void collectInstancesForSVGElement(SVGElement* element, HashSet<SVGElement*>& instances)
+static inline void collectInstancesForSVGElement(SVGElement* element, WillBeHeapHashSet<RawPtrWillBeWeakMember<SVGElement> >& instances)
 {
     ASSERT(element);
     if (element->containingShadowRoot())
         return;
 
     ASSERT(!element->instanceUpdatesBlocked());
 
     instances = element->instancesForElement();
 }
 
 bool SVGElement::addEventListener(const AtomicString& eventType, PassRefPtr<EventListener> prpListener, bool useCapture)
 {
     RefPtr<EventListener> listener = prpListener;
 
     // Add event listener to regular DOM element
     if (!Node::addEventListener(eventType, listener, useCapture))
         return false;
 
     // Add event listener to all shadow tree DOM element instances
-    HashSet<SVGElement*> instances;
+    WillBeHeapHashSet<RawPtrWillBeWeakMember<SVGElement> > instances;
     collectInstancesForSVGElement(this, instances);
-    const HashSet<SVGElement*>::const_iterator end = instances.end();
-    for (HashSet<SVGElement*>::const_iterator it = instances.begin(); it != end; ++it) {
+    const WillBeHeapHashSet<RawPtrWillBeWeakMember<SVGElement> >::const_iterator end = instances.end();
+    for (WillBeHeapHashSet<RawPtrWillBeWeakMember<SVGElement> >::const_iterator it = instances.begin(); it != end; ++it) {
         bool result = (*it)->Node::addEventListener(eventType, listener, useCapture);
         ASSERT_UNUSED(result, result);
     }
 
     return true;
 }
 
 bool SVGElement::removeEventListener(const AtomicString& eventType, EventListener* listener, bool useCapture)
 {
-    HashSet<SVGElement*> instances;
+    WillBeHeapHashSet<RawPtrWillBeWeakMember<SVGElement> > instances;
     collectInstancesForSVGElement(this, instances);
     if (instances.isEmpty())
         return Node::removeEventListener(eventType, listener, useCapture);
 
     // EventTarget::removeEventListener creates a PassRefPtr around the given EventListener
     // object when creating a temporary RegisteredEventListener object used to look up the
     // event listener in a cache. If we want to be able to call removeEventListener() multiple
     // times on different nodes, we have to delay its immediate destruction, which would happen
     // after the first call below.
     RefPtr<EventListener> protector(listener);
 
     // Remove event listener from regular DOM element
     if (!Node::removeEventListener(eventType, listener, useCapture))
         return false;
 
     // Remove event listener from all shadow tree DOM element instances
-    const HashSet<SVGElement*>::const_iterator end = instances.end();
-    for (HashSet<SVGElement*>::const_iterator it = instances.begin(); it != end; ++it) {
+    const WillBeHeapHashSet<RawPtrWillBeWeakMember<SVGElement> >::const_iterator end = instances.end();
+    for (WillBeHeapHashSet<RawPtrWillBeWeakMember<SVGElement> >::const_iterator it = instances.begin(); it != end; ++it) {
         SVGElement* shadowTreeElement = *it;
         ASSERT(shadowTreeElement);
 
         if (shadowTreeElement->Node::removeEventListener(eventType, listener, useCapture))
             continue;
 
         // This case can only be hit for event listeners created from markup
         ASSERT(listener->wasCreatedFromMarkup());
 
         // If the event listener 'listener' has been created from markup and has been fired before
@@ skipping 184 matching lines @@
 }
 
 void SVGElement::invalidateInstances()
 {
     if (!inDocument())
         return;
 
     if (instanceUpdatesBlocked())
         return;
 
-    const HashSet<SVGElement*>& set = instancesForElement();
+    const WillBeHeapHashSet<RawPtrWillBeWeakMember<SVGElement> >& set = instancesForElement();
     if (set.isEmpty())
         return;
 
     // Mark all use elements referencing 'element' for rebuilding
-    const HashSet<SVGElement*>::const_iterator end = set.end();
-    for (HashSet<SVGElement*>::const_iterator it = set.begin(); it != end; ++it) {
+    const WillBeHeapHashSet<RawPtrWillBeWeakMember<SVGElement> >::const_iterator end = set.end();
+    for (WillBeHeapHashSet<RawPtrWillBeWeakMember<SVGElement> >::const_iterator it = set.begin(); it != end; ++it) {
         (*it)->setCorrespondingElement(0);
 
         if (SVGUseElement* element = (*it)->correspondingUseElement()) {
             ASSERT(element->inDocument());
             element->invalidateShadowTree();
         }
     }
 
     document().updateRenderTreeIfNeeded();
 }
@@ skipping 111 matching lines @@
         animatableAttributes.add(SVGNames::zAttr);
     }
 
     if (name == classAttr)
         return true;
 
     return animatableAttributes.contains(name);
 }
 #endif
 }