Rename and improve "traceable" templates.

third_party/WebKit/Source/wtf/HashTraits.h

 /*
  * Copyright (C) 2005, 2006, 2007, 2008, 2011, 2012 Apple Inc. All rights reserved.
  *
  * 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,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 43 matching lines @@
     static const bool hasIsEmptyValueFunction = false;
 
     // The starting table size. Can be overridden when we know beforehand that a
     // hash table will have at least N entries.
 #if defined(MEMORY_SANITIZER_INITIAL_SIZE)
     static const unsigned minimumTableSize = 1;
 #else
     static const unsigned minimumTableSize = 8;
 #endif
 
+    // When a hash table backing store is traced, its elements will be
+    // traced if their class type has a trace method. However, weak-referenced
+    // elements should not be traced then, but handled by the weak processing
+    // phase that follows.
     template <typename U = void>
-    struct NeedsTracingLazily {

[haraken, 2016/06/12 07:11:31]

Nit: I'm okay with keeping the word "lazily" to make it clearer that the trait
needs to be instantiated lazily.

BTW, do we have any verification that the trait is instantiated lazily (i.e., at
a proper timing)?

[sof, 2016/06/12 07:29:44]

None other than it would fail to compile, i think. Exposing that (instantiation)
implementation detail in the name of this nested template, doesn't gain us much
imho.

-        static const bool value = NeedsTracing<T>::value;
+    struct IsTraceableInCollection {
+        static const bool value = IsTraceable<T>::value && !IsWeak<T>::value;
     };
 
     // The NeedsToForbidGCOnMove flag is used to make the hash table move
     // operations safe when GC is enabled: if a move constructor invokes
     // an allocation triggering the GC then it should be invoked within GC
     // forbidden scope.
     template <typename U = void>
     struct NeedsToForbidGCOnMove {
         // TODO(yutak): Consider using of std:::is_trivially_move_constructible
         // when it is accessible.
@@ skipping 218 matching lines @@
 struct KeyValuePairHashTraits : GenericHashTraits<KeyValuePair<typename KeyTraitsArg::TraitType, typename ValueTraitsArg::TraitType>> {
     typedef KeyTraitsArg KeyTraits;
     typedef ValueTraitsArg ValueTraits;
     typedef KeyValuePair<typename KeyTraits::TraitType, typename ValueTraits::TraitType> TraitType;
     typedef KeyValuePair<typename KeyTraits::EmptyValueType, typename ValueTraits::EmptyValueType> EmptyValueType;
 
     static const bool emptyValueIsZero = KeyTraits::emptyValueIsZero && ValueTraits::emptyValueIsZero;
     static EmptyValueType emptyValue() { return KeyValuePair<typename KeyTraits::EmptyValueType, typename ValueTraits::EmptyValueType>(KeyTraits::emptyValue(), ValueTraits::emptyValue()); }
 
     template <typename U = void>
-    struct NeedsTracingLazily {
-        static const bool value = NeedsTracingTrait<KeyTraits>::value || NeedsTracingTrait<ValueTraits>::value;
+    struct IsTraceableInCollection {
+        static const bool value = IsTraceableInCollectionTrait<KeyTraits>::value || IsTraceableInCollectionTrait<ValueTraits>::value;
     };
 
     template <typename U = void>
     struct NeedsToForbidGCOnMove {
         static const bool value = KeyTraits::template NeedsToForbidGCOnMove<>::value || ValueTraits::template NeedsToForbidGCOnMove<>::value;
     };
 
     static const WeakHandlingFlag weakHandlingFlag = (KeyTraits::weakHandlingFlag == WeakHandlingInCollections || ValueTraits::weakHandlingFlag == WeakHandlingInCollections) ? WeakHandlingInCollections : NoWeakHandlingInCollections;
 
     static const unsigned minimumTableSize = KeyTraits::minimumTableSize;
@@ skipping 28 matching lines @@
 struct TraceInCollectionTrait;
 
 } // namespace WTF
 
 using WTF::HashTraits;
 using WTF::PairHashTraits;
 using WTF::NullableHashTraits;
 using WTF::SimpleClassHashTraits;
 
 #endif // WTF_HashTraits_h