Oilpan: Remove support for tracing of off-heap ListHashSets.

Source/platform/heap/HeapTest.cpp

 /*
  * 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 1999 matching lines @@
     explicit ShouldBeTraced(IntWrapper* wrapper) : m_wrapper(wrapper) { }
     void trace(Visitor* visitor) { visitor->trace(m_wrapper); }
     Member<IntWrapper> m_wrapper;
 };
 
 class OffHeapContainer : public GarbageCollectedFinalized<OffHeapContainer> {
 public:
     static OffHeapContainer* create() { return new OffHeapContainer(); }
 
     static const int iterations = 300;
-    static const int deadWrappers = 2400;
+    static const int deadWrappers = 2100;
 
     OffHeapContainer()
     {
         for (int i = 0; i < iterations; i++) {
             m_deque1.append(ShouldBeTraced(IntWrapper::create(i)));
             m_vector1.append(ShouldBeTraced(IntWrapper::create(i)));
             m_deque2.append(IntWrapper::create(i));
             m_vector2.append(IntWrapper::create(i));
             m_hashSet.add(IntWrapper::create(i));
             m_hashMap.add(i + 103, IntWrapper::create(i));
-            m_listHashSet.add(IntWrapper::create(i));
             m_ownedVector.append(adoptPtr(new ShouldBeTraced(IntWrapper::create(i))));
         }
 
         Deque<ShouldBeTraced>::iterator d1Iterator(m_deque1.begin());
         Vector<ShouldBeTraced>::iterator v1Iterator(m_vector1.begin());
         Deque<Member<IntWrapper> >::iterator d2Iterator(m_deque2.begin());
         Vector<Member<IntWrapper> >::iterator v2Iterator(m_vector2.begin());
         HashSet<Member<IntWrapper> >::iterator setIterator(m_hashSet.begin());
         HashMap<int, Member<IntWrapper> >::iterator mapIterator(m_hashMap.begin());
-        ListHashSet<Member<IntWrapper> >::iterator listSetIterator(m_listHashSet.begin());
         Vector<OwnPtr<ShouldBeTraced> >::iterator ownedVectorIterator(m_ownedVector.begin());
 
         for (int i = 0; i < iterations; i++) {
             EXPECT_EQ(i, m_vector1[i].m_wrapper->value());
             EXPECT_EQ(i, m_vector2[i]->value());
             EXPECT_EQ(i, d1Iterator->m_wrapper->value());
             EXPECT_EQ(i, v1Iterator->m_wrapper->value());
             EXPECT_EQ(i, d2Iterator->get()->value());
             EXPECT_EQ(i, v2Iterator->get()->value());
-            EXPECT_EQ(i, listSetIterator->get()->value());
             EXPECT_EQ(i, ownedVectorIterator->get()->m_wrapper->value());
             int value = setIterator->get()->value();
             EXPECT_LE(0, value);
             EXPECT_GT(iterations, value);
             value = mapIterator->value.get()->value();
             EXPECT_LE(0, value);
             EXPECT_GT(iterations, value);
             ++d1Iterator;
             ++v1Iterator;
             ++d2Iterator;
             ++v2Iterator;
             ++setIterator;
             ++mapIterator;
-            ++listSetIterator;
             ++ownedVectorIterator;
         }
         EXPECT_EQ(d1Iterator, m_deque1.end());
         EXPECT_EQ(v1Iterator, m_vector1.end());
         EXPECT_EQ(d2Iterator, m_deque2.end());
         EXPECT_EQ(v2Iterator, m_vector2.end());
         EXPECT_EQ(setIterator, m_hashSet.end());
         EXPECT_EQ(mapIterator, m_hashMap.end());
-        EXPECT_EQ(listSetIterator, m_listHashSet.end());
         EXPECT_EQ(ownedVectorIterator, m_ownedVector.end());
     }
 
     void trace(Visitor* visitor)
     {
         visitor->trace(m_deque1);
         visitor->trace(m_vector1);
         visitor->trace(m_deque2);
         visitor->trace(m_vector2);
         visitor->trace(m_hashSet);
         visitor->trace(m_hashMap);
-        visitor->trace(m_listHashSet);
-        visitor->trace(m_listHashSet);
         visitor->trace(m_ownedVector);
     }
 
     Deque<ShouldBeTraced> m_deque1;
     Vector<ShouldBeTraced> m_vector1;
     Deque<Member<IntWrapper> > m_deque2;
     Vector<Member<IntWrapper> > m_vector2;
     HashSet<Member<IntWrapper> > m_hashSet;
     HashMap<int, Member<IntWrapper> > m_hashMap;
-    ListHashSet<Member<IntWrapper> > m_listHashSet;
     Vector<OwnPtr<ShouldBeTraced> > m_ownedVector;
 };
 
 const int OffHeapContainer::iterations;
 const int OffHeapContainer::deadWrappers;
 
 // These class definitions test compile-time asserts with transition
 // types. They are therefore unused in test code and just need to
 // compile. This is intentional; do not delete the A and B classes below.
 class A : public WillBeGarbageCollectedMixin {
@@ skipping 2744 matching lines @@
 };
 
 volatile uintptr_t DeadBitTester::s_workerObjectPointer = 0;
 
 TEST(HeapTest, ObjectDeadBit)
 {
     DeadBitTester::test();
 }
 
 } // WebCore namespace