Remove heap/*.cpp files

sky/engine/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 1509 matching lines @@
 #if ENABLE(ASSERT) || defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER)
     memset(result, 0, payloadSize);
 #endif
     ASSERT(heapPageFromAddress(headerAddress + allocationSize - 1));
     return result;
 }
 
 template<typename T, typename HeapTraits>
 Address Heap::allocate(size_t size)
 {
-    ThreadState* state = ThreadStateFor<ThreadingTrait<T>::Affinity>::state();
-    ASSERT(state->isAllocationAllowed());
-    const GCInfo* gcInfo = GCInfoTrait<T>::get();
-    int heapIndex = HeapTraits::index(gcInfo->hasFinalizer());
-    BaseHeap* heap = state->heap(heapIndex);
-    return static_cast<typename HeapTraits::HeapType*>(heap)->allocate(size, gcInfo);
+    ASSERT_NOT_REACHED();
+    return 0;
 }
 
 template<typename T>
 Address Heap::reallocate(void* previous, size_t size)
 {
     if (!size) {
         // If the new size is 0 this is equivalent to either
         // free(previous) or malloc(0). In both cases we do
         // nothing and return 0.
         return 0;
@@ skipping 66 matching lines @@
         return 0;
     }
 
     static void deleteArray(void* ptr)
     {
         ASSERT_NOT_REACHED();
     }
 
     static bool isAllocationAllowed()
     {
-        return ThreadState::current()->isAllocationAllowed();
+        ASSERT_NOT_REACHED();
+        return false;
     }
 
     static void markUsingGCInfo(Visitor* visitor, const void* buffer)
     {
         visitor->mark(buffer, FinalizedHeapObjectHeader::fromPayload(buffer)->traceCallback());
     }
 
     static void markNoTracing(Visitor* visitor, const void* t) { visitor->markNoTracing(t); }
 
     template<typename T, typename Traits>
@@ skipping 778 matching lines @@
 };
 
 template<typename T>
 struct IfWeakMember<WeakMember<T> > {
     static bool isDead(Visitor* visitor, const WeakMember<T>& t) { return !visitor->isAlive(t.get()); }
 };
 
 }
 
 #endif // Heap_h