Oilpan: insist on eager sweeping for some objects.

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 1101 matching lines @@
             if (size < 32)
                 return NormalPage1HeapIndex;
             return NormalPage2HeapIndex;
         }
         if (size < 128)
             return NormalPage3HeapIndex;
         return NormalPage4HeapIndex;
     }
 };
 
+// TODO(Oilpan): enable these macros when enabling lazy sweeping, non-Oilpan.
+#if ENABLE(OILPAN)
 #define EAGERLY_SWEEP(TYPE)                 \
 template<typename T>                        \
 class HeapIndexTrait<T, typename WTF::EnableIf<WTF::IsSubclass<T, TYPE>::value>::Type> { \
 public:                                     \
     static int heapIndexForObject(size_t)   \
     {                                       \
         return EagerSweepHeapIndex;         \
     }                                       \
 }
 
+#define EAGERLY_SWEEP_TEMPLATE(TYPE)        \
+template<typename T>                        \
+class HeapIndexTrait<T, typename WTF::EnableIf<WTF::IsSubclassOfTemplate<T, TYPE>::value>::Type> { \
+public:                                     \
+    static int heapIndexForObject(size_t)   \
+    {                                       \
+        return EagerSweepHeapIndex;         \
+    }                                       \
+}
+
+// Overlapping and ambiguous specializations may happen
+// for Blink's DOMWindowProperty -- provide a convenience

[haraken, 2015/05/21 11:45:39]

Just to confirm: If we write:

  EAGERLY_SWEEP_TEMPLATE(LifecycleObserver);
  EAGERLY_SWEEP(DOMWindowProperty);

then we hit the disambiguation error when encountering a class that is both
LifecycleObserver and DOMWindowProperty?

[sof, 2015/05/21 11:47:50]

Correct.

[haraken, 2015/05/21 13:23:24]

Makes sense.

I'm OK with this but would slightly prefer hard-coding the things instead of
introducing new macros, for clarity.

  // TODO: These are layering violations. Remove this once
  // the DOMWindowProperty and LifecycleObserver are moved to
  // Oilpan by default.
  class DOMWindowProperty;
  class LifecycleObserver;
  template<typename T>
  class HeapIndexTrait<T, typename WTF::EnableIf<WTF::IsSubclassOfTemplate<T,
LifecycleObserver>::value || WTF::IsSubclass<T,
DOMWindowProperty>::value>::Type> {
    ...;
  };

What do you think?

+// macro which lifts the disambiguation to the EnableIf<>
+// predicate.
+#define EAGERLY_SWEEP_IF_NOT(TYPE, INSTANCE_OF) \
+template<typename T>                            \
+class HeapIndexTrait<T, typename WTF::EnableIf<!WTF::IsSubclassOfTemplate<T, INSTANCE_OF>::value && WTF::IsSubclass<T, TYPE>::value>::Type> { \
+public:                                         \
+    static int heapIndexForObject(size_t)       \
+    {                                           \
+        return EagerSweepHeapIndex;             \
+    }                                           \
+}
+#else
+#define EAGERLY_SWEEP(TYPE)
+#define EAGERLY_SWEEP_TEMPLATE(TYPE)
+#define EAGERLY_SWEEP_IF_NOT(TYPE, COND)
+#endif
+
 NO_SANITIZE_ADDRESS inline
 size_t HeapObjectHeader::size() const
 {
     size_t result = m_encoded & headerSizeMask;
     // Large objects should not refer to header->size().
     // The actual size of a large object is stored in
     // LargeObjectPage::m_payloadSize.
     ASSERT(result != largeObjectSizeInHeader);
     ASSERT(!pageFromObject(this)->isLargeObjectPage());
     return result;
@@ skipping 131 matching lines @@
     size_t copySize = previousHeader->payloadSize();
     if (copySize > size)
         copySize = size;
     memcpy(address, previous, copySize);
     return address;
 }
 
 } // namespace blink
 
 #endif // Heap_h