remove most uses of raw handle constructors

include/v8.h

 // Copyright 2012 the V8 project authors. 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
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 105 matching lines @@
 class Date;
 class DeclaredAccessorDescriptor;
 class External;
 class Function;
 class FunctionTemplate;
 class HeapProfiler;
 class ImplementationUtilities;
 class Int32;
 class Integer;
 class Isolate;
-class LocalContext;
 class Number;
 class NumberObject;
 class Object;
 class ObjectOperationDescriptor;
 class ObjectTemplate;
 class Primitive;
 class RawOperationDescriptor;
 class Signature;
 class StackFrame;
 class StackTrace;
@@ skipping 18 matching lines @@
 class DeclaredAccessorDescriptor;
 class ObjectOperationDescriptor;
 class RawOperationDescriptor;
 
 namespace internal {
 class Arguments;
 class Heap;
 class HeapObject;
 class Isolate;
 class Object;
-template<typename T>
-class CustomArguments;
+template<typename T> class CustomArguments;
 class PropertyCallbackArguments;
 class FunctionCallbackArguments;
 }
 
 
 /**
  * General purpose unique identifier.
  */
 class UniqueId {
  public:
@@ skipping 181 matching lines @@
 
  private:
 #endif
   /**
    * Creates a new handle for the specified value.
    */
   V8_INLINE(explicit Handle(T* val)) : val_(val) {}
 #endif
 
  private:
+  friend class Utils;
   template<class F> friend class Persistent;
   template<class F> friend class Local;
   friend class Arguments;
   template<class F> friend class FunctionCallbackInfo;
   template<class F> friend class PropertyCallbackInfo;
-  friend class String;
-  friend class Object;
+  template<class F> friend class CustomArguments;
   friend class AccessorInfo;
   friend Handle<Primitive> Undefined(Isolate* isolate);
   friend Handle<Primitive> Null(Isolate* isolate);
   friend Handle<Boolean> True(Isolate* isolate);
   friend Handle<Boolean> False(Isolate* isolate);
   friend class Context;
-  friend class InternalHandleHelper;
-  friend class LocalContext;
   friend class HandleScope;
 
 #ifndef V8_USE_UNSAFE_HANDLES
   V8_INLINE(static Handle<T> New(Isolate* isolate, T* that));
 #endif
 
   T* val_;
 };
 
 
@@ skipping 54 matching lines @@
   V8_INLINE(static Local<T> New(Isolate* isolate, const Persistent<T>& that));
 
 #ifndef V8_ALLOW_ACCESS_TO_RAW_HANDLE_CONSTRUCTOR
 
  private:
 #endif
   template <class S> V8_INLINE(Local(S* that) : Handle<T>(that)) { }
 #endif
 
  private:
+  friend class Utils;
   template<class F> friend class Persistent;
   template<class F> friend class Handle;
   friend class Arguments;
   template<class F> friend class FunctionCallbackInfo;
   template<class F> friend class PropertyCallbackInfo;
   friend class String;
   friend class Object;
   friend class AccessorInfo;
   friend class Context;
-  friend class InternalHandleHelper;
-  friend class LocalContext;
+  template<class F> friend class CustomArguments;
   friend class HandleScope;
 
   V8_INLINE(static Local<T> New(Isolate* isolate, T* that));
 };
 
 /**
  * An object reference that is independent of any handle scope.  Where
  * a Local handle only lives as long as the HandleScope in which it was
  * allocated, a Persistent handle remains valid until it is explicitly
  * disposed.
@@ skipping 26 matching lines @@
   // TODO(dcarney): remove somehow before cutover
   // The handle should either be 0, or a pointer to a live cell.
   V8_INLINE(void Clear()) { val_ = 0; }
 
   /**
    * A constructor that creates a new global cell pointing to that. In contrast
    * to the copy constructor, this creates a new persistent handle which needs
    * to be separately disposed.
    */
   template <class S> V8_INLINE(Persistent(Isolate* isolate, Handle<S> that))
-      : val_(*New(isolate, that)) { }
+      : val_(New(isolate, *that)) { }
 
   template <class S> V8_INLINE(Persistent(Isolate* isolate,
                                           Persistent<S>& that)) // NOLINT
-      : val_(*New(isolate, that)) { }
+      : val_(New(isolate, *that)) { }
 
 #else
   /**
    * Creates an empty persistent handle that doesn't point to any
    * storage cell.
    */
   V8_INLINE(Persistent()) : Handle<T>() { }
 
   /**
    * Creates a persistent handle for the same storage cell as the
@@ skipping 58 matching lines @@
     if (!that.IsEmpty()) T::Cast(*that);
 #endif
     return reinterpret_cast<Persistent<T>&>(that);
   }
 
   template <class S> V8_INLINE(Persistent<S>& As()) { // NOLINT
     return Persistent<S>::Cast(*this);
   }
 #endif
 
+#ifdef V8_USE_UNSAFE_HANDLES
   V8_DEPRECATED(static Persistent<T> New(Handle<T> that));
-
-  /**
-   * Creates a new persistent handle for an existing local or persistent handle.
-   */
-  // TODO(dcarney): remove before cutover
   V8_INLINE(static Persistent<T> New(Isolate* isolate, Handle<T> that));
-#ifndef V8_USE_UNSAFE_HANDLES
-  // TODO(dcarney): remove before cutover
   V8_INLINE(static Persistent<T> New(Isolate* isolate, Persistent<T> that));
 #endif
 
 #ifndef V8_USE_UNSAFE_HANDLES
   template <class S> V8_INLINE(
       bool operator==(const Persistent<S>& that) const) {
     internal::Object** a = reinterpret_cast<internal::Object**>(**this);
     internal::Object** b = reinterpret_cast<internal::Object**>(*that);
     if (a == 0) return b == 0;
     if (b == 0) return false;
@@ skipping 156 matching lines @@
     return *this;
   }
 
  public:
 #ifndef V8_ALLOW_ACCESS_TO_RAW_HANDLE_CONSTRUCTOR
 
  private:
 #endif
   // TODO(dcarney): remove before cutover
   template <class S> V8_INLINE(Persistent(S* that)) : val_(that) { }
-  // TODO(dcarney): remove before cutover
-  template <class S> V8_INLINE(Persistent(Persistent<S> that))
-      : val_(*that) {
-    TYPE_CHECK(T, S);
-  }
+
   // TODO(dcarney): remove before cutover
   V8_INLINE(T* operator*() const) { return val_; }
 
  private:
   // TODO(dcarney): remove before cutover
   V8_INLINE(T* operator->() const) { return val_; }
  public:
 #endif
 
  private:
+  friend class Utils;
   template<class F> friend class Handle;
   template<class F> friend class Local;
+  template<class F> friend class Persistent;
   template<class F> friend class ReturnValue;
-  friend class ImplementationUtilities;
-  friend class ObjectTemplate;
-  friend class Context;
-  friend class InternalHandleHelper;
-  friend class LocalContext;
 
-  V8_INLINE(static Persistent<T> New(Isolate* isolate, T* that));
+  V8_INLINE(static T* New(Isolate* isolate, T* that));
 
 #ifndef V8_USE_UNSAFE_HANDLES
   T* val_;
 #endif
 };
 
 
  /**
  * A stack-allocated class that governs a number of local handles.
  * After a handle scope has been created, all local handles will be
@@ skipping 4686 matching lines @@
 template <class T>
 Local<T> Local<T>::New(Isolate* isolate, T* that) {
   if (that == NULL) return Local<T>();
   T* that_ptr = that;
   internal::Object** p = reinterpret_cast<internal::Object**>(that_ptr);
   return Local<T>(reinterpret_cast<T*>(HandleScope::CreateHandle(
       reinterpret_cast<internal::Isolate*>(isolate), *p)));
 }
 
 
+#ifdef V8_USE_UNSAFE_HANDLES
 template <class T>
 Persistent<T> Persistent<T>::New(Handle<T> that) {
   return New(Isolate::GetCurrent(), that.val_);
 }
 
 
 template <class T>
 Persistent<T> Persistent<T>::New(Isolate* isolate, Handle<T> that) {
   return New(Isolate::GetCurrent(), that.val_);
 }
 
-#ifndef V8_USE_UNSAFE_HANDLES
 template <class T>
 Persistent<T> Persistent<T>::New(Isolate* isolate, Persistent<T> that) {
   return New(Isolate::GetCurrent(), that.val_);
 }
 #endif
 
+
 template <class T>
-Persistent<T> Persistent<T>::New(Isolate* isolate, T* that) {
-  if (that == NULL) return Persistent<T>();
+T* Persistent<T>::New(Isolate* isolate, T* that) {
+  if (that == NULL) return NULL;
   internal::Object** p = reinterpret_cast<internal::Object**>(that);
-  return Persistent<T>(reinterpret_cast<T*>(
+  return reinterpret_cast<T*>(
       V8::GlobalizeReference(reinterpret_cast<internal::Isolate*>(isolate),
-                             p)));
+                             p));
 }
 
 
 template <class T>
 bool Persistent<T>::IsIndependent() const {
   typedef internal::Internals I;
   if (this->IsEmpty()) return false;
   return I::GetNodeFlag(reinterpret_cast<internal::Object**>(this->val_),
                         I::kNodeIsIndependentShift);
 }
@@ skipping 821 matching lines @@
 
 
 }  // namespace v8
 
 
 #undef V8EXPORT
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_