A64: Synchronize with r15204.

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 38 matching lines @@
 };
 
 // --- Handles ---
 
 #define TYPE_CHECK(T, S)                                       \
   while (false) {                                              \
     *(static_cast<T* volatile*>(0)) = static_cast<S*>(0);      \
   }
 
 
-#define V8_USE_UNSAFE_HANDLES
-
 /**
  * An object reference managed by the v8 garbage collector.
  *
  * All objects returned from v8 have to be tracked by the garbage
  * collector so that it knows that the objects are still alive.  Also,
  * because the garbage collector may move objects, it is unsafe to
  * point directly to an object.  Instead, all objects are stored in
  * handles which are known by the garbage collector and updated
  * whenever an object moves.  Handles should always be passed by value
  * (except in cases like out-parameters) and they should never be
@@ skipping 121 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 internal::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 internal::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 11 matching lines @@
  */
 template <class T> class Persistent // NOLINT
 #ifdef V8_USE_UNSAFE_HANDLES
     : public Handle<T> {
 #else
   { // NOLINT
 #endif
  public:
 #ifndef V8_USE_UNSAFE_HANDLES
   V8_INLINE(Persistent()) : val_(0) { }
-  V8_INLINE(~Persistent()) {
-    // TODO(dcarney): add this back before cutover.
-    // Dispose();
-  }
+  // TODO(dcarney): add this back before cutover.
+//  V8_INLINE(~Persistent()) {
+//  Dispose();
+//  }
   V8_INLINE(bool IsEmpty() const) { return val_ == 0; }
   // 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 29 matching lines @@
   template<typename S, typename P>
   V8_INLINE(void MakeWeak(
       P* parameters,
       typename WeakReferenceCallbacks<S, P>::Revivable callback));
 
   template<typename P>
   V8_INLINE(void MakeWeak(
       P* parameters,
       typename WeakReferenceCallbacks<T, P>::Revivable callback));
 
-  // TODO(dcarney): deprecate
   template<typename S, typename P>
-  V8_INLINE(void MakeWeak(
+  V8_DEPRECATED(void MakeWeak(
       Isolate* isolate,
       P* parameters,
-      typename WeakReferenceCallbacks<S, P>::Revivable callback)) {
-    MakeWeak<S, P>(parameters, callback);
-  }
+      typename WeakReferenceCallbacks<S, P>::Revivable callback));
 
-  // TODO(dcarney): deprecate
   template<typename P>
-  V8_INLINE(void MakeWeak(
+  V8_DEPRECATED(void MakeWeak(
       Isolate* isolate,
       P* parameters,
-      typename WeakReferenceCallbacks<T, P>::Revivable callback)) {
-    MakeWeak<P>(parameters, callback);
-  }
+      typename WeakReferenceCallbacks<T, P>::Revivable callback));
 
   V8_INLINE(void ClearWeak());
 
   // TODO(dcarney): deprecate
   V8_INLINE(void ClearWeak(Isolate* isolate)) { ClearWeak(); }
 
   /**
    * Marks the reference to this object independent. Garbage collector is free
    * to ignore any object groups containing this object. Weak callback for an
    * independent handle should not assume that it will be preceded by a global
@@ skipping 90 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 4509 matching lines @@
   static const int kExternalTwoByteRepresentationTag = 0x02;
   static const int kExternalAsciiRepresentationTag = 0x06;
 
   static const int kIsolateStateOffset = 0;
   static const int kIsolateEmbedderDataOffset = 1 * kApiPointerSize;
   static const int kIsolateRootsOffset = 3 * kApiPointerSize;
   static const int kUndefinedValueRootIndex = 5;
   static const int kNullValueRootIndex = 7;
   static const int kTrueValueRootIndex = 8;
   static const int kFalseValueRootIndex = 9;
-  static const int kEmptyStringRootIndex = 130;
+  static const int kEmptyStringRootIndex = 131;
 
   static const int kNodeClassIdOffset = 1 * kApiPointerSize;
   static const int kNodeFlagsOffset = 1 * kApiPointerSize + 3;
   static const int kNodeStateMask = 0xf;
   static const int kNodeStateIsWeakValue = 2;
   static const int kNodeStateIsNearDeathValue = 4;
   static const int kNodeIsIndependentShift = 4;
   static const int kNodeIsPartiallyDependentShift = 5;
 
-  static const int kJSObjectType = 0xaf;
+  static const int kJSObjectType = 0xb0;
   static const int kFirstNonstringType = 0x80;
   static const int kOddballType = 0x83;
-  static const int kForeignType = 0x87;
+  static const int kForeignType = 0x88;
 
   static const int kUndefinedOddballKind = 5;
   static const int kNullOddballKind = 3;
 
   V8_INLINE(static bool HasHeapObjectTag(internal::Object* value)) {
     return ((reinterpret_cast<intptr_t>(value) & kHeapObjectTagMask) ==
             kHeapObjectTag);
   }
 
   V8_INLINE(static int SmiValue(internal::Object* value)) {
@@ skipping 143 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 43 matching lines @@
 template <class T>
 template <typename P>
 void Persistent<T>::MakeWeak(
     P* parameters,
     typename WeakReferenceCallbacks<T, P>::Revivable callback) {
   MakeWeak<T, P>(parameters, callback);
 }
 
 
 template <class T>
+template <typename S, typename P>
+void Persistent<T>::MakeWeak(
+    Isolate* isolate,
+    P* parameters,
+    typename WeakReferenceCallbacks<S, P>::Revivable callback) {
+  MakeWeak<S, P>(parameters, callback);
+}
+
+
+template <class T>
+template<typename P>
+void Persistent<T>::MakeWeak(
+    Isolate* isolate,
+    P* parameters,
+    typename WeakReferenceCallbacks<T, P>::Revivable callback) {
+  MakeWeak<P>(parameters, callback);
+}
+
+
+template <class T>
 void Persistent<T>::ClearWeak() {
   V8::ClearWeak(reinterpret_cast<internal::Object**>(this->val_));
 }
 
 
 template <class T>
 void Persistent<T>::MarkIndependent() {
   typedef internal::Internals I;
   if (this->IsEmpty()) return;
   I::UpdateNodeFlag(reinterpret_cast<internal::Object**>(this->val_),
@@ skipping 98 matching lines @@
   TYPE_CHECK(T, S);
   if (V8_UNLIKELY(handle.IsEmpty())) {
     *value_ = GetDefaultValue();
   } else {
     *value_ = *reinterpret_cast<internal::Object**>(*handle);
   }
 }
 
 template<typename T>
 void ReturnValue<T>::Set(double i) {
+  TYPE_CHECK(T, Number);
   Set(Number::New(GetIsolate(), i));
 }
 
 template<typename T>
 void ReturnValue<T>::Set(int32_t i) {
+  TYPE_CHECK(T, Integer);
   typedef internal::Internals I;
   if (V8_LIKELY(I::IsValidSmi(i))) {
     *value_ = I::IntToSmi(i);
     return;
   }
   Set(Integer::New(i, GetIsolate()));
 }
 
 template<typename T>
 void ReturnValue<T>::Set(uint32_t i) {
+  TYPE_CHECK(T, Integer);
   typedef internal::Internals I;
   // Can't simply use INT32_MAX here for whatever reason.
   bool fits_into_int32_t = (i & (1 << 31)) == 0;
   if (V8_LIKELY(fits_into_int32_t)) {
     Set(static_cast<int32_t>(i));
     return;
   }
   Set(Integer::NewFromUnsigned(i, GetIsolate()));
 }
 
 template<typename T>
 void ReturnValue<T>::Set(bool value) {
+  TYPE_CHECK(T, Boolean);
   typedef internal::Internals I;
   int root_index;
   if (value) {
     root_index = I::kTrueValueRootIndex;
   } else {
     root_index = I::kFalseValueRootIndex;
   }
   *value_ = *I::GetRoot(GetIsolate(), root_index);
 }
 
 template<typename T>
 void ReturnValue<T>::SetNull() {
+  TYPE_CHECK(T, Primitive);
   typedef internal::Internals I;
   *value_ = *I::GetRoot(GetIsolate(), I::kNullValueRootIndex);
 }
 
 template<typename T>
 void ReturnValue<T>::SetUndefined() {
+  TYPE_CHECK(T, Primitive);
   typedef internal::Internals I;
   *value_ = *I::GetRoot(GetIsolate(), I::kUndefinedValueRootIndex);
 }
 
 template<typename T>
 void ReturnValue<T>::SetEmptyString() {
+  TYPE_CHECK(T, String);
   typedef internal::Internals I;
   *value_ = *I::GetRoot(GetIsolate(), I::kEmptyStringRootIndex);
 }
 
 template<typename T>
 Isolate* ReturnValue<T>::GetIsolate() {
   // Isolate is always the pointer below the default value on the stack.
   return *reinterpret_cast<Isolate**>(&value_[-2]);
 }
 
@@ skipping 589 matching lines @@
 
 
 }  // namespace v8
 
 
 #undef V8EXPORT
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_