[oilpan] Move IDBDatabase, IDBDatabaseCallbacks, IDBDatabaseBackendInterface and other related clas…

Source/heap/Visitor.h

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 19 matching lines @@
 
 #ifndef Visitor_h
 #define Visitor_h
 
 #include "ThreadState.h"
 #include <wtf/Deque.h>
 #include <wtf/Forward.h>
 #include <wtf/HashMap.h>
 #include <wtf/HashSet.h>
 #include <wtf/HashTraits.h>
+#include <wtf/ListHashSet.h>
 
 #define TRACE_GC_MARKING 0
 #define TRACE_GC_FINALIZATION 0
 
 #if TRACE_GC_MARKING || TRACE_GC_FINALIZATION
 #define TRACE_GC_USING_CLASSOF 1
 #else
 #define TRACE_GC_USING_CLASSOF 0
 #endif
 
@@ skipping 216 matching lines @@
 
     // Doesn't keep the visited thing alive, but will write null to the
     // WeakMember later if the pointed-to object is dead.
     template<typename T>
     void trace(const WeakMember<T>& t)
     {
         registerWeakCell(t.cell());
     }
 
     // The following visit methods are for off-heap collections.
-    template<typename T, size_t N>
-    void trace(const Vector<T, N, WTF::FastAllocator>& vector)
+    template<typename T, size_t inlineCapacity>
+    void trace(const Vector<T, inlineCapacity, WTF::FastAllocator>& vector)
     {
-        CollectionVisitingTrait<Vector<T, N, WTF::FastAllocator> >::visit(this, vector);
+        CollectionVisitingTrait<Vector<T, inlineCapacity, WTF::FastAllocator> >::visit(this, vector);
     }
 
     template<typename T, typename U, typename V>
     void trace(const HashSet<T, WTF::FastAllocator, U, V>& hashSet)
     {
         CollectionVisitingTrait<HashSet<T, WTF::FastAllocator, U, V> >::visit(this, hashSet);
     }
 
+    template<typename T, size_t inlineCapacity, typename U>
+    void trace(const ListHashSet<T, inlineCapacity, U>& hashSet)
+    {
+        CollectionVisitingTrait<ListHashSet<T, inlineCapacity, U> >::visit(this, hashSet);
+    }
+
     template<typename T, size_t N>
     void trace(const Deque<T, N>& deque)
     {
         CollectionVisitingTrait<Deque<T, N> >::visit(this, deque);
     }
 
     template<typename T, typename U, typename V, typename W, typename X>
     void trace(const HashMap<T, U, WTF::FastAllocator, V, W, X>& map)
     {
         CollectionVisitingTrait<HashMap<T, U, WTF::FastAllocator, V, W, X> >::visit(this, map);
@@ skipping 105 matching lines @@
             for (typename HashSet::const_iterator it = set.begin(), end = set.end(); it != end; ++it)
                 VisitCollectionBackingTrait<Traits::needsVisiting, Traits::isWeak, false, T, Traits>::visit(v, *it);
         }
         if (Traits::isWeak) {
             if (!set.isEmpty())
                 v->registerWeakPointers(&set, processWeakOffHeapHashSet<T, HashFunctions, Traits>);
         }
     }
 };
 
+template<typename T, size_t inlineCapacity, typename HashFunctions>
+struct CollectionVisitingTrait<WTF::ListHashSet<T, inlineCapacity, HashFunctions> > {
+    typedef WTF::ListHashSet<T, inlineCapacity, HashFunctions> ListHashSet;
+
+    static void visit(Visitor* visitor, const ListHashSet& set)
+    {
+        if (set.isEmpty())
+            return;
+        for (typename ListHashSet::const_iterator it = set.begin(), end = set.end(); it != end; ++it)
+            visitor->trace(*it);
+    }
+};
+
 template<typename Key, typename Value, typename HashFunctions, typename KeyTraits, typename ValueTraits>
 struct CollectionVisitingTrait<WTF::HashMap<Key, Value, WTF::FastAllocator, HashFunctions, KeyTraits, ValueTraits> > {
     typedef WTF::HashMap<Key, Value, WTF::FastAllocator, HashFunctions, KeyTraits, ValueTraits> HashMap;
 
     static void visit(Visitor* v, const HashMap& map)
     {
         if (map.isEmpty())
             return;
         if (WTF::NeedsVisiting<Key>::value || WTF::NeedsVisiting<Value>::value) {
             for (typename HashMap::const_iterator it = map.begin(), end = map.end(); it != end; ++it) {
@@ skipping 106 matching lines @@
 class HeapVisitable {
 public:
     virtual void trace(Visitor*) = 0;
     virtual ~HeapVisitable()
     {
     }
 };
 
 }
 #endif