[api] Disable new and delete using = delete.

include/v8.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /** \mainpage V8 API Reference Guide
  *
  * V8 is Google's open source JavaScript engine.
  *
  * This set of documents provides reference material generated from the
  * V8 header file, include/v8.h.
@@ skipping 864 matching lines @@
    * Counts the number of allocated handles.
    */
   static int NumberOfHandles(Isolate* isolate);
 
   V8_INLINE Isolate* GetIsolate() const {
     return reinterpret_cast<Isolate*>(isolate_);
   }
 
   HandleScope(const HandleScope&) = delete;
   void operator=(const HandleScope&) = delete;
+  void* operator new(size_t size) = delete;
+  void operator delete(void*, size_t) = delete;
 
  protected:
   V8_INLINE HandleScope() {}
 
   void Initialize(Isolate* isolate);
 
   static internal::Object** CreateHandle(internal::Isolate* isolate,
                                          internal::Object* value);
 
  private:
   // Uses heap_object to obtain the current Isolate.
   static internal::Object** CreateHandle(internal::HeapObject* heap_object,
                                          internal::Object* value);
 
-  // Make it hard to create heap-allocated or illegal handle scopes by
-  // disallowing certain operations.
-  void* operator new(size_t size);
-  void operator delete(void*, size_t);
-
   internal::Isolate* isolate_;
   internal::Object** prev_next_;
   internal::Object** prev_limit_;
 
   // Local::New uses CreateHandle with an Isolate* parameter.
   template<class F> friend class Local;
 
   // Object::GetInternalField and Context::GetEmbedderData use CreateHandle with
   // a HeapObject* in their shortcuts.
   friend class Object;
@@ skipping 16 matching lines @@
    */
   template <class T>
   V8_INLINE Local<T> Escape(Local<T> value) {
     internal::Object** slot =
         Escape(reinterpret_cast<internal::Object**>(*value));
     return Local<T>(reinterpret_cast<T*>(slot));
   }
 
   EscapableHandleScope(const EscapableHandleScope&) = delete;
   void operator=(const EscapableHandleScope&) = delete;
+  void* operator new(size_t size) = delete;
+  void operator delete(void*, size_t) = delete;
 
  private:
   internal::Object** Escape(internal::Object** escape_value);
-
-  // Make it hard to create heap-allocated or illegal handle scopes by
-  // disallowing certain operations.
-  void* operator new(size_t size);
-  void operator delete(void*, size_t);
-
   internal::Object** escape_slot_;
 };
 
 class V8_EXPORT SealHandleScope {
  public:
   SealHandleScope(Isolate* isolate);
   ~SealHandleScope();
 
   SealHandleScope(const SealHandleScope&) = delete;
   void operator=(const SealHandleScope&) = delete;
+  void* operator new(size_t size) = delete;
+  void operator delete(void*, size_t) = delete;
 
  private:
-  // Make it hard to create heap-allocated or illegal handle scopes by
-  // disallowing certain operations.
-  void* operator new(size_t size);
-  void operator delete(void*, size_t);
-
   internal::Isolate* const isolate_;
   internal::Object** prev_limit_;
   int prev_sealed_level_;
 };
 
 
 // --- Special objects ---
 
 
 /**
@@ skipping 5487 matching lines @@
    * pending activity for the handle.
    */
   void VisitWeakHandles(PersistentHandleVisitor* visitor);
 
   /**
    * Check if this isolate is in use.
    * True if at least one thread Enter'ed this isolate.
    */
   bool IsInUse();
 
+  Isolate() = delete;
+  ~Isolate() = delete;
   Isolate(const Isolate&) = delete;
   Isolate& operator=(const Isolate&) = delete;
+  void* operator new(size_t size) = delete;
+  void operator delete(void*, size_t) = delete;
 
  private:
   template <class K, class V, class Traits>
   friend class PersistentValueMapBase;
 
-  Isolate();
-  ~Isolate();
-  void* operator new(size_t size);
-  void operator delete(void*, size_t);
-
   void SetObjectGroupId(internal::Object** object, UniqueId id);
   void SetReferenceFromGroup(UniqueId id, internal::Object** object);
   void SetReference(internal::Object** parent, internal::Object** child);
   void ReportExternalAllocationLimitReached();
 };
 
 class V8_EXPORT StartupData {
  public:
   const char* data;
   int raw_size;
@@ skipping 645 matching lines @@
    * UseAfterReturn is enabled, then the address returned will be the address
    * of the C++ try catch handler itself.
    */
   static void* JSStackComparableAddress(v8::TryCatch* handler) {
     if (handler == NULL) return NULL;
     return handler->js_stack_comparable_address_;
   }
 
   TryCatch(const TryCatch&) = delete;
   void operator=(const TryCatch&) = delete;
+  void* operator new(size_t size) = delete;
+  void operator delete(void*, size_t) = delete;
 
  private:
   void ResetInternal();
 
-  // Make it hard to create heap-allocated TryCatch blocks.
-  void* operator new(size_t size);
-  void operator delete(void*, size_t);
-
   v8::internal::Isolate* isolate_;
   v8::TryCatch* next_;
   void* exception_;
   void* message_obj_;
   void* js_stack_comparable_address_;
   bool is_verbose_ : 1;
   bool can_continue_ : 1;
   bool capture_message_ : 1;
   bool rethrow_ : 1;
   bool has_terminated_ : 1;
@@ skipping 1850 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // INCLUDE_V8_H_