DevTools: make DOMNodeIds a trivial wrapper around WeakIdentifierMap

Source/core/dom/WeakIdentifierMap.h

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef WeakIdentifierMap_h
 #define WeakIdentifierMap_h
 
+#include "platform/heap/Handle.h"
 #include "wtf/HashMap.h"
+#include "wtf/Vector.h"
 
 namespace blink {
+
+#if !ENABLE(OILPAN)
 template<typename T> struct WeakIdentifierMapTraits {
     static void removedFromIdentifierMap(T*) { }
     static void addedToIdentifierMap(T*) { }
 };
 
 template<typename T, typename Traits = WeakIdentifierMapTraits<T>> class WeakIdentifierMap {
 public:
     ~WeakIdentifierMap()
     {
         ObjectToWeakIdentifierMaps& allMaps = ObjectToWeakIdentifierMaps::instance();
         for (auto& map : m_objectToIdentifier) {
             T* object = map.key;
             if (allMaps.removedFromMap(object, this))
                 Traits::removedFromIdentifierMap(object);
         }
     }
 
-    void put(T* object, int identifier)
-    {
-        ASSERT(object && !m_objectToIdentifier.contains(object));
-        m_objectToIdentifier.set(object, identifier);
-        m_identifierToObject.set(identifier, object);
-
-        ObjectToWeakIdentifierMaps& maps = ObjectToWeakIdentifierMaps::instance();
-        if (maps.addedToMap(object, this))
-            Traits::addedToIdentifierMap(object);
-    }
-
     int identifier(T* object)
     {
-        return m_objectToIdentifier.get(object);
+        int result = m_objectToIdentifier.get(object);
+        if (!result) {
+            static int s_lastId = 0;
+            result = ++s_lastId;
+            put(object, result);
+        }
+        return result;
     }
 
     T* lookup(int identifier)
     {
         return m_identifierToObject.get(identifier);
     }
 
     static void notifyObjectDestroyed(T* object)
     {
         ObjectToWeakIdentifierMaps::instance().objectDestroyed(object);
     }
 
 private:
+    void put(T* object, int identifier)
+    {
+        ASSERT(object && !m_objectToIdentifier.contains(object));
+        m_objectToIdentifier.set(object, identifier);
+        m_identifierToObject.set(identifier, object);
+
+        ObjectToWeakIdentifierMaps& maps = ObjectToWeakIdentifierMaps::instance();
+        if (maps.addedToMap(object, this))
+            Traits::addedToIdentifierMap(object);
+    }
+
     class ObjectToWeakIdentifierMaps {
         typedef WeakIdentifierMap<T> IdentifierMap;
     public:
         bool addedToMap(T* object, IdentifierMap* map)
         {
             typename ObjectToMapList::AddResult result = m_objectToMapList.add(object, nullptr);
             if (result.isNewEntry)
                 result.storedValue->value = adoptPtr(new MapList());
             result.storedValue->value->append(map);
             return result.isNewEntry;
@@ skipping 34 matching lines @@
     };
 
     void objectDestroyed(T* object)
     {
         int identifier = m_objectToIdentifier.take(object);
         ASSERT(identifier);
         m_identifierToObject.remove(identifier);
     }
 
     typedef HashMap<T*, int> ObjectToIdentifier;
+    typedef HashMap<int, T*> IdentifierToObject;
+
     ObjectToIdentifier m_objectToIdentifier;
-    typedef HashMap<int, T*> IdentifierToObject;
     IdentifierToObject m_identifierToObject;
 };
 
+#else // ENABLE(OILPAN)
+
+template<typename T> class WeakIdentifierMap : public GarbageCollected<WeakIdentifierMap<T>> {
+public:
+    WeakIdentifierMap()
+        : m_objectToIdentifier(new ObjectToIdentifier())
+        , m_identifierToObject(new IdentifierToObject())
+    {
+    }
+
+    int identifier(T* object)
+    {
+        int result = m_objectToIdentifier->get(object);
+        if (!result) {
+            static int s_lastId = 0;
+            result = ++s_lastId;
+            put(object, result);
+        }
+        return result;
+    }
+
+    T* lookup(int identifier)
+    {
+        return m_identifierToObject->get(identifier);
+    }
+
+    static void notifyObjectDestroyed(T* object) { }
+
+    DEFINE_INLINE_TRACE()
+    {
+        visitor->trace(m_objectToIdentifier);
+        visitor->trace(m_identifierToObject);
+    }
+
+private:
+    void put(T* object, int identifier)
+    {
+        ASSERT(object && !m_objectToIdentifier->contains(object));
+        m_objectToIdentifier->set(object, identifier);
+        m_identifierToObject->set(identifier, object);
+    }
+
+    typedef HeapHashMap<WeakMember<T>, int> ObjectToIdentifier;
+    typedef HeapHashMap<int, WeakMember<T>> IdentifierToObject;
+
+    Member<ObjectToIdentifier> m_objectToIdentifier;
+    Member<IdentifierToObject> m_identifierToObject;
+};
+
+#endif // ENABLE(OILPAN)
+
 }
+
 #endif // WeakIdentifierMap_h