Make platform/heap to use USING_FAST_MALLOC.

third_party/WebKit/Source/platform/heap/Handle.h

 /*
  * Copyright (C) 2014 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 20 matching lines @@
 #ifndef Handle_h
 #define Handle_h
 
 #include "platform/heap/Heap.h"
 #include "platform/heap/HeapAllocator.h"
 #include "platform/heap/InlinedGlobalMarkingVisitor.h"
 #include "platform/heap/PersistentNode.h"
 #include "platform/heap/ThreadState.h"
 #include "platform/heap/TraceTraits.h"
 #include "platform/heap/Visitor.h"
+#include "wtf/Allocator.h"
 #include "wtf/Functional.h"
 #include "wtf/HashFunctions.h"
 #include "wtf/Locker.h"
 #include "wtf/MainThread.h"
 #include "wtf/RawPtr.h"
 #include "wtf/RefCounted.h"
 #include "wtf/TypeTraits.h"
 
 #if defined(LEAK_SANITIZER)
 #include "wtf/LeakAnnotations.h"
@@ skipping 14 matching lines @@
     WeakPersistentConfiguration
 };
 
 enum CrossThreadnessPersistentConfiguration {
     SingleThreadPersistentConfiguration,
     CrossThreadPersistentConfiguration
 };
 
 template<typename T, WeaknessPersistentConfiguration weaknessConfiguration, CrossThreadnessPersistentConfiguration crossThreadnessConfiguration>
 class PersistentBase {
+    USING_FAST_MALLOC(PersistentBase);
     IS_PERSISTENT_REFERENCE_TYPE();
 public:
     PersistentBase() : m_raw(nullptr)
     {
         initialize();
     }
 
     PersistentBase(std::nullptr_t) : m_raw(nullptr)
     {
         initialize();
@@ skipping 609 matching lines @@
     }
 };
 
 // Members are used in classes to contain strong pointers to other oilpan heap
 // allocated objects.
 // All Member fields of a class must be traced in the class' trace method.
 // During the mark phase of the GC all live objects are marked as live and
 // all Member fields of a live object will be traced marked as live as well.
 template<typename T>
 class Member {
+    DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 public:
     Member() : m_raw(nullptr)
     {
     }
 
     Member(std::nullptr_t) : m_raw(nullptr)
     {
     }
 
     Member(T* raw) : m_raw(raw)
@@ skipping 477 matching lines @@
 #define DEFINE_EMPTY_DESTRUCTOR_WILL_BE_REMOVED(type) \
     type::~type() { }
 
 #define DEFINE_STATIC_REF_WILL_BE_PERSISTENT(type, name, arguments) \
     DEFINE_STATIC_REF(type, name, arguments)
 
 #endif // ENABLE(OILPAN)
 
 template<typename T, bool = IsGarbageCollectedType<T>::value>
 class RawPtrOrMemberTrait {
+    STATIC_ONLY(RawPtrOrMemberTrait)
 public:
     using Type = RawPtr<T>;
 };
 
 template<typename T>
 class RawPtrOrMemberTrait<T, true> {
+    STATIC_ONLY(RawPtrOrMemberTrait)
 public:
     using Type = Member<T>;
 };
 
 // Abstraction for injecting calls to an object's 'dispose()' method
 // on leaving a stack scope, ensuring earlier release of resources
 // than waiting until the object is eventually GCed.
 template<typename T, void (T::*Disposer)() = (&T::dispose)>
 class ScopedDisposal {
     STACK_ALLOCATED();
@@ skipping 39 matching lines @@
 //  private:
 //     ...
 //     SelfKeepAlive m_keepAlive;
 //  };
 //
 // The responsibility to call clear() in a timely fashion resides with the implementation
 // of the object.
 //
 //
 template<typename Self>
-class SelfKeepAlive {
+class SelfKeepAlive final {
+    DISALLOW_NEW();
 public:
     SelfKeepAlive()
     {
     }
 
     explicit SelfKeepAlive(Self* self)
     {
         assign(self);
     }
 
@@ skipping 65 matching lines @@
 #define LEAK_SANITIZER_DISABLED_SCOPE LeakSanitizerDisableScope lsanDisabledScope
 #else
 #define LEAK_SANITIZER_DISABLED_SCOPE
 #endif
 
 } // namespace blink
 
 namespace WTF {
 
 template<typename T> struct PtrHash<blink::Member<T>> : PtrHash<T*> {
+    STATIC_ONLY(PtrHash);
     template<typename U>
     static unsigned hash(const U& key) { return PtrHash<T*>::hash(key); }
     static bool equal(T* a, const blink::Member<T>& b) { return a == b; }
     static bool equal(const blink::Member<T>& a, T* b) { return a == b; }
     template<typename U, typename V>
     static bool equal(const U& a, const V& b) { return a == b; }
 };
 
 template<typename T> struct PtrHash<blink::WeakMember<T>> : PtrHash<blink::Member<T>> {
+    STATIC_ONLY(PtrHash);
 };
 
 template<typename T> struct PtrHash<blink::UntracedMember<T>> : PtrHash<blink::Member<T>> {
+    STATIC_ONLY(PtrHash);
 };
 
 // PtrHash is the default hash for hash tables with members.
 template<typename T> struct DefaultHash<blink::Member<T>> {
+    STATIC_ONLY(DefaultHash);
     using Hash = PtrHash<blink::Member<T>>;
 };
 
 template<typename T> struct DefaultHash<blink::WeakMember<T>> {
+    STATIC_ONLY(DefaultHash);
     using Hash = PtrHash<blink::WeakMember<T>>;
 };
 
 template<typename T> struct DefaultHash<blink::UntracedMember<T>> {
+    STATIC_ONLY(DefaultHash);
     using Hash = PtrHash<blink::UntracedMember<T>>;
 };
 
 template<typename T>
 struct NeedsTracing<blink::Member<T>> {
+    STATIC_ONLY(NeedsTracing);
     static const bool value = true;
 };
 
 template<typename T>
 struct IsWeak<blink::WeakMember<T>> {
+    STATIC_ONLY(IsWeak);
     static const bool value = true;
 };
 
 template<typename T> inline T* getPtr(const blink::Member<T>& p)
 {
     return p.get();
 }
 
 template<typename T> inline T* getPtr(const blink::Persistent<T>& p)
 {
     return p.get();
 }
 
 // For wtf/Functional.h
 template<typename T, bool isGarbageCollected> struct PointerParamStorageTraits;
 
 template<typename T>
 struct PointerParamStorageTraits<T*, false> {
+    STATIC_ONLY(PointerParamStorageTraits);
     static_assert(sizeof(T), "T must be fully defined");
     using StorageType = T*;
 
     static StorageType wrap(T* value) { return value; }
     static T* unwrap(const StorageType& value) { return value; }
 };
 
 template<typename T>
 struct PointerParamStorageTraits<T*, true> {
+    STATIC_ONLY(PointerParamStorageTraits);
     static_assert(sizeof(T), "T must be fully defined");
     using StorageType = blink::CrossThreadPersistent<T>;
 
     static StorageType wrap(T* value) { return value; }
     static T* unwrap(const StorageType& value) { return value.get(); }
 };
 
 template<typename T>
 struct ParamStorageTraits<T*> : public PointerParamStorageTraits<T*, blink::IsGarbageCollectedType<T>::value> {
+    STATIC_ONLY(ParamStorageTraits);
     static_assert(sizeof(T), "T must be fully defined");
 };
 
 template<typename T>
 struct ParamStorageTraits<RawPtr<T>> : public PointerParamStorageTraits<T*, blink::IsGarbageCollectedType<T>::value> {
+    STATIC_ONLY(ParamStorageTraits);
     static_assert(sizeof(T), "T must be fully defined");
 };
 
 template<typename T>
 struct ParamStorageTraits<blink::CrossThreadWeakPersistentThisPointer<T>> {
+    STATIC_ONLY(ParamStorageTraits);
     static_assert(sizeof(T), "T must be fully defined");
     using StorageType = blink::CrossThreadWeakPersistent<T>;
 
     static StorageType wrap(const blink::CrossThreadWeakPersistentThisPointer<T>& value) { return value.value(); }
 
     // WTF::FunctionWrapper<> handles WeakPtr<>, so recast this weak persistent
     // into it.
     //
     // TODO(sof): remove this hack once wtf/Functional.h can also work with a type like
     // CrossThreadWeakPersistent<>.
     static WeakPtr<T> unwrap(const StorageType& value) { return WeakPtr<T>(WeakReference<T>::create(value.get())); }
 };
 
 } // namespace WTF
 
 #endif