remove memoryinstrumentation

Source/wtf/ListHashSet.h

 /*
  * Copyright (C) 2005, 2006, 2007, 2008, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2011, Benjamin Poulain <ikipou@gmail.com>
  *
  * 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 76 matching lines @@
         ListHashSet(const ListHashSet&);
         ListHashSet& operator=(const ListHashSet&);
         ~ListHashSet();
 
         void swap(ListHashSet&);
 
         int size() const;
         int capacity() const;
         bool isEmpty() const;
 
-        size_t sizeInBytes() const;
-
         iterator begin();
         iterator end();
         const_iterator begin() const;
         const_iterator end() const;
 
         reverse_iterator rbegin();
         reverse_iterator rend();
         const_reverse_iterator rbegin() const;
         const_reverse_iterator rend() const;
 
@@ skipping 102 matching lines @@
                 node->m_isAllocated = false;
 #endif
                 node->m_next = m_freeList;
                 m_freeList = node;
                 return;
             }
 
             fastFree(node);
         }
 
+    private:
+        Node* pool() { return reinterpret_cast_ptr<Node*>(m_pool.pool); }
+        Node* pastPool() { return pool() + m_poolSize; }
         bool inPool(Node* node)
         {
             return node >= pool() && node < pastPool();
         }
 
-    private:
-        Node* pool() { return reinterpret_cast_ptr<Node*>(m_pool.pool); }
-        Node* pastPool() { return pool() + m_poolSize; }
-
         Node* m_freeList;
         bool m_isDoneWithInitialFreeList;
         static const size_t m_poolSize = inlineCapacity;
         union {
             char pool[sizeof(Node) * m_poolSize];
             double forAlignment;
         } m_pool;
     };
 
     template<typename ValueArg, size_t inlineCapacity> struct ListHashSetNode {
@@ skipping 322 matching lines @@
         return m_impl.capacity(); 
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     inline bool ListHashSet<T, inlineCapacity, U>::isEmpty() const
     {
         return m_impl.isEmpty(); 
     }
 
     template<typename T, size_t inlineCapacity, typename U>
-    size_t ListHashSet<T, inlineCapacity, U>::sizeInBytes() const
-    {
-        size_t result = sizeof(*this) + sizeof(*m_allocator);
-        result += sizeof(typename ImplType::ValueType) * m_impl.capacity();
-        for (Node* node = m_head; node; node = node->m_next) {
-            if (!m_allocator->inPool(node))
-                result += sizeof(Node);
-        }
-        return result;
-    }
-
-    template<typename T, size_t inlineCapacity, typename U>
     inline typename ListHashSet<T, inlineCapacity, U>::iterator ListHashSet<T, inlineCapacity, U>::begin()
     {
         return makeIterator(m_head); 
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     inline typename ListHashSet<T, inlineCapacity, U>::iterator ListHashSet<T, inlineCapacity, U>::end()
     {
         return makeIterator(0);
     }
@@ skipping 325 matching lines @@
     inline void deleteAllValues(const ListHashSet<T, inlineCapacity, U>& collection)
     {
         deleteAllValues<true, typename ListHashSet<T, inlineCapacity, U>::ValueType>(collection.m_impl);
     }
 
 } // namespace WTF
 
 using WTF::ListHashSet;
 
 #endif /* WTF_ListHashSet_h */