Remove heap/*.cpp files

sky/engine/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 86 matching lines @@
     // No locking required. Just check that we are at the right thread.
     class Lock {
     public:
         Lock() { state()->checkThread(); }
     };
 
 private:
     static ThreadState* state() { return ThreadStateFor<Affinity>::state(); }
 };
 
-// RootsAccessor for Persistent that provides synchronized access to global
-// list of persistent handles. Can be used for persistent handles that are
-// passed between threads.
-class GlobalPersistents {
-public:
-    static PersistentNode* roots() { return ThreadState::globalRoots(); }
-
-    class Lock {
-    public:
-        Lock() : m_locker(ThreadState::globalRootsMutex()) { }
-    private:
-        MutexLocker m_locker;
-    };
-};
-
 // Base class for persistent handles. RootsAccessor specifies which list to
 // link resulting handle into. Owner specifies the class containing trace
 // method.
 template<typename RootsAccessor, typename Owner>
 class PersistentBase : public PersistentNode {
 public:
     ~PersistentBase()
     {
         typename RootsAccessor::Lock lock;
         ASSERT(m_roots == RootsAccessor::roots()); // Check that the thread is using the same roots list.
@@ skipping 19 matching lines @@
     }
 
     inline explicit PersistentBase(const PersistentBase& otherref)
         : PersistentNode(otherref.m_trace)
 #if ENABLE(ASSERT)
         , m_roots(RootsAccessor::roots())
 #endif
     {
         // We don't support allocation of thread local Persistents while doing
         // thread shutdown/cleanup.
-        ASSERT(!ThreadState::current()->isTerminating());
         typename RootsAccessor::Lock lock;
         ASSERT(otherref.m_roots == m_roots); // Handles must belong to the same list.
         PersistentBase* other = const_cast<PersistentBase*>(&otherref);
         m_prev = other;
         m_next = other->m_next;
         other->m_next = this;
         m_next->m_prev = this;
     }
 
     inline PersistentBase& operator=(const PersistentBase& otherref) { return *this; }
@@ skipping 33 matching lines @@
 private:
     PersistentAnchor() : PersistentNode(TraceMethodDelegate<PersistentAnchor, &PersistentAnchor::trace>::trampoline)
     {
         m_next = this;
         m_prev = this;
     }
 
     friend class ThreadState;
 };
 
-#if ENABLE(ASSERT)
-    // For global persistent handles we cannot check that the
-    // pointer is in the heap because that would involve
-    // inspecting the heap of running threads.
-#define ASSERT_IS_VALID_PERSISTENT_POINTER(pointer) \
-    bool isGlobalPersistent = WTF::IsSubclass<RootsAccessor, GlobalPersistents>::value; \
-    ASSERT(!pointer || isGlobalPersistent || ThreadStateFor<ThreadingTrait<T>::Affinity>::state()->contains(pointer))
-#else
-#define ASSERT_IS_VALID_PERSISTENT_POINTER(pointer)
-#endif
-
 template<typename T>
 class CrossThreadPersistent;
 
 // Persistent handles are used to store pointers into the
 // managed heap. As long as the Persistent handle is alive
 // the GC will keep the object pointed to alive. Persistent
 // handles can be stored in objects and they are not scoped.
 // Persistent handles must not be used to contain pointers
 // between objects that are in the managed heap. They are only
 // meant to point to managed heap objects from variables/members
 // outside the managed heap.
 //
 // A Persistent is always a GC root from the point of view of
 // the garbage collector.
 //
 // We have to construct and destruct Persistent with default RootsAccessor in
 // the same thread.
 template<typename T, typename RootsAccessor /* = ThreadLocalPersistents<ThreadingTrait<T>::Affinity > */ >
 class Persistent : public PersistentBase<RootsAccessor, Persistent<T, RootsAccessor> > {
     WTF_DISALLOW_CONSTRUCTION_FROM_ZERO(Persistent);
     WTF_DISALLOW_ZERO_ASSIGNMENT(Persistent);
 public:
     Persistent() : m_raw(0) { }
 
     Persistent(std::nullptr_t) : m_raw(0) { }
 
     Persistent(T* raw) : m_raw(raw)
     {
-        ASSERT_IS_VALID_PERSISTENT_POINTER(m_raw);
         recordBacktrace();
     }
 
     explicit Persistent(T& raw) : m_raw(&raw)
     {
-        ASSERT_IS_VALID_PERSISTENT_POINTER(m_raw);
         recordBacktrace();
     }
 
     Persistent(const Persistent& other) : m_raw(other) { recordBacktrace(); }
 
     template<typename U>
     Persistent(const Persistent<U, RootsAccessor>& other) : m_raw(other) { recordBacktrace(); }
 
     template<typename U>
     Persistent(const Member<U>& other) : m_raw(other) { recordBacktrace(); }
@@ skipping 95 matching lines @@
 
     String m_tracingName;
 #else
     inline void recordBacktrace() const { }
 #endif
     T* m_raw;
 
     friend class CrossThreadPersistent<T>;
 };
 
-// Unlike Persistent, we can destruct a CrossThreadPersistent in a thread
-// different from the construction thread.
-template<typename T>
-class CrossThreadPersistent : public Persistent<T, GlobalPersistents> {
-    WTF_DISALLOW_CONSTRUCTION_FROM_ZERO(CrossThreadPersistent);
-    WTF_DISALLOW_ZERO_ASSIGNMENT(CrossThreadPersistent);
-public:
-    CrossThreadPersistent(T* raw) : Persistent<T, GlobalPersistents>(raw) { }
-
-    using Persistent<T, GlobalPersistents>::operator=;
-};
-
 // FIXME: derive affinity based on the collection.
 template<typename Collection, ThreadAffinity Affinity = AnyThread>
 class PersistentHeapCollectionBase
     : public Collection
     , public PersistentBase<ThreadLocalPersistents<Affinity>, PersistentHeapCollectionBase<Collection, Affinity> > {
     // We overload the various new and delete operators with using the WTF DefaultAllocator to ensure persistent
     // heap collections are always allocated off-heap. This allows persistent collections to be used in
     // DEFINE_STATIC_LOCAL et. al.
     WTF_USE_ALLOCATOR(PersistentHeapCollectionBase, WTF::DefaultAllocator);
 public:
@@ skipping 507 matching lines @@
 struct ParamStorageTraits<T*> : public PointerParamStorageTraits<T*, false> {
 };
 
 template<typename T>
 struct ParamStorageTraits<RawPtr<T> > : public PointerParamStorageTraits<T*, false> {
 };
 
 } // namespace WTF
 
 #endif