Enable WTF::HashSet<OwnPtr<> >

Source/wtf/HashTable.h

 /*
  * Copyright (C) 2005, 2006, 2007, 2008, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008 David Levin <levin@chromium.org>
  *
  * 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 281 matching lines @@
     public:
         typedef HashTableIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator> iterator;
         typedef HashTableConstIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator> const_iterator;
         typedef Traits ValueTraits;
         typedef Key KeyType;
         typedef typename KeyTraits::PeekInType KeyPeekInType;
         typedef typename KeyTraits::PassInType KeyPassInType;
         typedef Value ValueType;
         typedef Extractor ExtractorType;
         typedef KeyTraits KeyTraitsType;
-        typedef typename Traits::PeekInType ValuePeekInType;
+        typedef typename Traits::PassInType ValuePassInType;
         typedef IdentityHashTranslator<HashFunctions> IdentityTranslatorType;
         typedef HashTableAddResult<HashTable, ValueType> AddResult;
 
 #if DUMP_HASHTABLE_STATS_PER_TABLE
         struct Stats {
             Stats()
                 : numAccesses(0)
                 , numRehashes(0)
                 , numRemoves(0)
                 , numReinserts(0)
@@ skipping 54 matching lines @@
         // buckets, and iterating an empty table is a common case that's worth optimizing.
         iterator begin() { return isEmpty() ? end() : makeIterator(m_table); }
         iterator end() { return makeKnownGoodIterator(m_table + m_tableSize); }
         const_iterator begin() const { return isEmpty() ? end() : makeConstIterator(m_table); }
         const_iterator end() const { return makeKnownGoodConstIterator(m_table + m_tableSize); }
 
         unsigned size() const { return m_keyCount; }
         unsigned capacity() const { return m_tableSize; }
         bool isEmpty() const { return !m_keyCount; }
 
-        AddResult add(ValuePeekInType value)
+        AddResult add(ValuePassInType value)
         {
             return add<IdentityTranslatorType>(Extractor::extract(value), value);
         }
 
         // A special version of add() that finds the object by hashing and comparing
         // with some other type, to avoid the cost of type conversion if the object is already
         // in the table.
         template<typename HashTranslator, typename T, typename Extra> AddResult add(const T& key, const Extra&);
         template<typename HashTranslator, typename T, typename Extra> AddResult addPassingHashCode(const T& key, const Extra&);
 
@@ skipping 898 matching lines @@
         CollectionIterator end(toBeRemoved.end());
         for (CollectionIterator it(toBeRemoved.begin()); it != end; ++it)
             collection.remove(*it);
     }
 
 } // namespace WTF
 
 #include "wtf/HashIterators.h"
 
 #endif // WTF_HashTable_h