Statically disallow delete' over heap collection objects.

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

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef HeapAllocator_h
 #define HeapAllocator_h
 
 #include "platform/heap/Heap.h"
 #include "platform/heap/Persistent.h"
 #include "platform/heap/TraceTraits.h"
@@ skipping 88 matching lines @@
         return allocateHashTableBacking<T, HashTable>(size);
     }
     static void freeHashTableBacking(void* address);
     static bool expandHashTableBacking(void*, size_t);
 
     template <typename Return, typename Metadata>
     static Return malloc(size_t size, const char* typeName)
     {
         return reinterpret_cast<Return>(ThreadHeap::allocate<Metadata>(size, IsEagerlyFinalizedType<Metadata>::value));
     }
-    static void free(void* address) { }
+
+#if OS(WIN) && COMPILER(MSVC)
+    // MSVC eagerly instantiates the unused 'operator delete',
+    // provide a version that asserts and fails at run-time if
+    // used.
+    // Elsewhere we expect compilation to fail if 'delete' is
+    // attempted used and instantiated with a HeapAllocator-based
+    // object, as HeapAllocator::free is not provided.
+    static void free(void*)
+    {
+        NOTREACHED();
+    }
+#endif
+
     template<typename T>
     static void* newArray(size_t bytes)
     {
         ASSERT_NOT_REACHED();
         return 0;
     }
 
     static void deleteArray(void* ptr)
     {
         ASSERT_NOT_REACHED();
@@ skipping 406 matching lines @@
     static const bool value = true;
 };
 
 template<typename T> struct HashTraits<blink::Persistent<T>> : HandleHashTraits<T, blink::Persistent<T>> { };
 
 template<typename T> struct HashTraits<blink::CrossThreadPersistent<T>> : HandleHashTraits<T, blink::CrossThreadPersistent<T>> { };
 
 } // namespace WTF
 
 #endif