Oilpan: rename EAGERLY_SWEEP() as EAGERLY_FINALIZED().

Source/platform/heap/Heap.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 1076 matching lines @@
 // It seems that the same type of objects are likely to be accessed together,
 // which means that we want to group objects by type. That's one reason
 // why we provide dedicated heaps for popular types (e.g., Node, CSSValue),
 // but it's not practical to prepare dedicated heaps for all types.
 // Thus we group objects by their sizes, hoping that this will approximately
 // group objects by their types.
 //
 // An exception to the use of sized heaps is made for class types that
 // require prompt finalization after a garbage collection. That is, their
 // instances have to be finalized early and cannot be delayed until lazy
-// sweeping kicks in for their heap and page. The EAGERLY_SWEEP()
+// sweeping kicks in for their heap and page. The EAGERLY_FINALIZE()
 // macro is used to declare a class (and its derived classes) as being
-// in need of 'eager sweeping'.
-//
-// TODO(Oilpan): the notion of eagerly swept object is at least needed
-// during the transition to enabling Oilpan always. Once passed, re-evaluate
-// if there is a need to keep this facility.
+// in need of eagerly finalized. Must be defined with 'public' visibility
+// for a class.
 //
 template<typename T, typename Enabled = void>
 class HeapIndexTrait {
 public:
     static int heapIndexForObject(size_t size)
     {
         if (size < 64) {
             if (size < 32)
                 return NormalPage1HeapIndex;
             return NormalPage2HeapIndex;
         }
         if (size < 128)
             return NormalPage3HeapIndex;
         return NormalPage4HeapIndex;
     }
 };
 
 // TODO(Oilpan): enable this macro when enabling lazy sweeping, non-Oilpan.
 #if ENABLE(OILPAN)
-#define EAGERLY_SWEEP() typedef int IsEagerlySweptMarker
+#define EAGERLY_FINALIZE() typedef int IsEagerlyFinalizedMarker
+#define EAGERLY_FINALIZE_WILL_BE_REMOVED()
 #else
-#define EAGERLY_SWEEP()
+#define EAGERLY_FINALIZE()
+// TODO(Oilpan): define in terms of Oilpan's EAGERLY_FINALIZE() once lazy
+// sweeping is enabled non-Oilpan.
+#define EAGERLY_FINALIZE_WILL_BE_REMOVED()
 #endif
 
 template<typename T>
-struct IsEagerlySweptType {
+struct IsEagerlyFinalizedType {
 private:
     typedef char YesType;
     struct NoType {
         char padding[8];
     };
 
-    template <typename U> static YesType checkMarker(typename U::IsEagerlySweptMarker*);
+    template <typename U> static YesType checkMarker(typename U::IsEagerlyFinalizedMarker*);
     template <typename U> static NoType checkMarker(...);
 
 public:
     static const bool value = sizeof(checkMarker<T>(nullptr)) == sizeof(YesType);
 };
 
 template<typename T>
-class HeapIndexTrait<T, typename WTF::EnableIf<IsEagerlySweptType<T>::value>::Type> {
+class HeapIndexTrait<T, typename WTF::EnableIf<IsEagerlyFinalizedType<T>::value>::Type> {

[haraken, 2015/05/26 13:06:35]

Just to confirm:

class A : GarbageCollected<A> {
  EAGERLY_FINALIZE();
  static A* create() {
    return new A; // This will be created in the eagerly sweep heap.
  }
};

class B : class A {
  static B* create() {
    return new B;  // Will this be created in the eagerly sweep heap?
  }
};

My question is whether the SFINAE returns true for sub-classes.

 public:
     static int heapIndexForObject(size_t)
     {
         return EagerSweepHeapIndex;
     }
 };
 
 NO_SANITIZE_ADDRESS inline
 size_t HeapObjectHeader::size() const
 {
@@ skipping 138 matching lines @@
     size_t copySize = previousHeader->payloadSize();
     if (copySize > size)
         copySize = size;
     memcpy(address, previous, copySize);
     return address;
 }
 
 } // namespace blink
 
 #endif // Heap_h