A64: Synchronize with r18444.

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 437 matching lines @@
  private:
   friend class internal::GlobalHandles;
   WeakCallbackData(Isolate* isolate, Local<T> handle, P* parameter)
     : isolate_(isolate), handle_(handle), parameter_(parameter) { }
   Isolate* isolate_;
   Local<T> handle_;
   P* parameter_;
 };
 
 
-// TODO(dcarney): Remove this class.
-template<typename T,
-         typename P,
-         typename M = NonCopyablePersistentTraits<T> >
-class WeakReferenceCallbacks {
- public:
-  typedef void (*Revivable)(Isolate* isolate,
-                            Persistent<T, M>* object,
-                            P* parameter);
-};
-
-
 /**
  * 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 PersistentBase handle remains valid until it is explicitly
  * disposed.
  *
  * A persistent handle contains a reference to a storage cell within
  * the v8 engine which holds an object value and which is updated by
  * the garbage collector whenever the object is moved.  A new storage
  * cell can be created using the constructor or PersistentBase::Reset and
@@ skipping 214 matching lines @@
   }
   /**
    * The destructor will dispose the Persistent based on the
    * kResetInDestructor flags in the traits class.  Since not calling dispose
    * can result in a memory leak, it is recommended to always set this flag.
    */
   V8_INLINE ~Persistent() {
     if (M::kResetInDestructor) this->Reset();
   }
 
-  V8_DEPRECATED("Use Reset instead",
-                V8_INLINE void Dispose()) { this->Reset(); }
-
   // TODO(dcarney): this is pretty useless, fix or remove
   template <class S>
   V8_INLINE static Persistent<T>& Cast(Persistent<S>& that) { // NOLINT
 #ifdef V8_ENABLE_CHECKS
     // If we're going to perform the type check then we have to check
     // that the handle isn't empty before doing the checked cast.
     if (!that.IsEmpty()) T::Cast(*that);
 #endif
     return reinterpret_cast<Persistent<T>&>(that);
   }
 
   // TODO(dcarney): this is pretty useless, fix or remove
   template <class S> V8_INLINE Persistent<S>& As() { // NOLINT
     return Persistent<S>::Cast(*this);
   }
 
-  template<typename S, typename P>
-  V8_DEPRECATED(
-      "Use SetWeak instead",
-      V8_INLINE void MakeWeak(
-          P* parameter,
-          typename WeakReferenceCallbacks<S, P>::Revivable callback));
-
-  template<typename P>
-  V8_DEPRECATED(
-      "Use SetWeak instead",
-      V8_INLINE void MakeWeak(
-          P* parameter,
-          typename WeakReferenceCallbacks<T, P>::Revivable callback));
-
   // This will be removed.
   V8_INLINE T* ClearAndLeak();
 
-  V8_DEPRECATED("This will be removed",
-                V8_INLINE void Clear()) { this->val_ = 0; }
-
   // TODO(dcarney): remove
 #ifndef V8_ALLOW_ACCESS_TO_RAW_HANDLE_CONSTRUCTOR
 
  private:
 #endif
   template <class S> V8_INLINE Persistent(S* that) : PersistentBase<T>(that) { }
 
   V8_INLINE T* operator*() const { return this->val_; }
 
  private:
@@ skipping 92 matching lines @@
  * garbage collector will no longer track the object stored in the
  * handle and may deallocate it.  The behavior of accessing a handle
  * for which the handle scope has been deleted is undefined.
  */
 class V8_EXPORT HandleScope {
  public:
   HandleScope(Isolate* isolate);
 
   ~HandleScope();
 
-  template <class T>
-  V8_DEPRECATED("Use EscapableHandleScope::Escape instead",
-                Local<T> Close(Handle<T> value));
-
   /**
    * Counts the number of allocated handles.
    */
   static int NumberOfHandles();
 
  private:
   /**
    * Creates a new handle with the given value.
    */
   static internal::Object** CreateHandle(internal::Isolate* isolate,
@@ skipping 18 matching lines @@
    public:
     internal::Object** next;
     internal::Object** limit;
     int level;
     V8_INLINE void Initialize() {
       next = limit = NULL;
       level = 0;
     }
   };
 
-  void Leave();
-
   internal::Isolate* isolate_;
   internal::Object** prev_next_;
   internal::Object** prev_limit_;
 
-  // TODO(dcarney): remove this field
-  // Allow for the active closing of HandleScopes which allows to pass a handle
-  // from the HandleScope being closed to the next top most HandleScope.
-  bool is_closed_;
-  internal::Object** RawClose(internal::Object** value);
-
   friend class ImplementationUtilities;
   friend class EscapableHandleScope;
   template<class F> friend class Handle;
   template<class F> friend class Local;
   friend class Object;
   friend class Context;
 };
 
 
 /**
@@ skipping 219 matching lines @@
   /**
    * Runs the script returning the resulting value.  If the script is
    * context independent (created using ::New) it will be run in the
    * currently entered context.  If it is context specific (created
    * using ::Compile) it will be run in the context in which it was
    * compiled.
    */
   Local<Value> Run();
 
   /**
-   * Returns the script id value.
-   */
-  V8_DEPRECATED("Use GetId instead", Local<Value> Id());
-
-  /**
    * Returns the script id.
    */
   int GetId();
 
   /**
    * Associate an additional data object with the script. This is mainly used
    * with the debugger as this data object is only available through the
    * debugger API.
    */
   void SetData(Handle<String> data);
@@ skipping 70 matching lines @@
   int GetEndColumn() const;
 
   /**
    * Passes on the value set by the embedder when it fed the script from which
    * this Message was generated to V8.
    */
   bool IsSharedCrossOrigin() const;
 
   // TODO(1245381): Print to a string instead of on a FILE.
   static void PrintCurrentStackTrace(Isolate* isolate, FILE* out);
-  V8_DEPRECATED("Will be removed",
-                static void PrintCurrentStackTrace(FILE* out));
 
   static const int kNoLineNumberInfo = 0;
   static const int kNoColumnInfo = 0;
   static const int kNoScriptIdInfo = 0;
 };
 
 
 /**
  * Representation of a JavaScript stack trace. The information collected is a
  * snapshot of the execution stack and the information remains valid after
@@ skipping 37 matching lines @@
    * Grab a snapshot of the current JavaScript execution stack.
    *
    * \param frame_limit The maximum number of stack frames we want to capture.
    * \param options Enumerates the set of things we will capture for each
    *   StackFrame.
    */
   static Local<StackTrace> CurrentStackTrace(
       Isolate* isolate,
       int frame_limit,
       StackTraceOptions options = kOverview);
-  V8_DEPRECATED("Will be removed",
-                static Local<StackTrace> CurrentStackTrace(
-                    int frame_limit, StackTraceOptions options = kOverview));
 };
 
 
 /**
  * A single JavaScript stack frame.
  */
 class V8_EXPORT StackFrame {
  public:
   /**
    * Returns the number, 1-based, of the line for the associate function call.
@@ skipping 311 matching lines @@
 
 
 /**
  * A primitive boolean value (ECMA-262, 4.3.14).  Either the true
  * or false value.
  */
 class V8_EXPORT Boolean : public Primitive {
  public:
   bool Value() const;
   V8_INLINE static Handle<Boolean> New(Isolate* isolate, bool value);
-  V8_DEPRECATED("Will be removed",
-                V8_INLINE static Handle<Boolean> New(bool value));
 };
 
 
 /**
  * A JavaScript string value (ECMA-262, 4.3.17).
  */
 class V8_EXPORT String : public Primitive {
  public:
   enum Encoding {
     UNKNOWN_ENCODING = 0x1,
@@ skipping 185 matching lines @@
   V8_INLINE ExternalStringResource* GetExternalStringResource() const;
 
   /**
    * Get the ExternalAsciiStringResource for an external ASCII string.
    * Returns NULL if IsExternalAscii() doesn't return true.
    */
   const ExternalAsciiStringResource* GetExternalAsciiStringResource() const;
 
   V8_INLINE static String* Cast(v8::Value* obj);
 
-  /**
-   * Allocates a new string from either UTF-8 encoded or ASCII data.
-   * The second parameter 'length' gives the buffer length. If omitted,
-   * the function calls 'strlen' to determine the buffer length.
-   */
-  V8_DEPRECATED(
-      "Use NewFromUtf8 instead",
-      V8_INLINE static Local<String> New(const char* data, int length = -1));
-
-  /** Allocates a new string from 16-bit character codes.*/
-  V8_DEPRECATED(
-      "Use NewFromTwoByte instead",
-      V8_INLINE static Local<String> New(
-          const uint16_t* data, int length = -1));
-
-  /**
-   * Creates an internalized string (historically called a "symbol",
-   * not to be confused with ES6 symbols). Returns one if it exists already.
-   */
-  V8_DEPRECATED(
-      "Use NewFromUtf8 instead",
-      V8_INLINE static Local<String> NewSymbol(
-          const char* data, int length = -1));
-
   enum NewStringType {
     kNormalString, kInternalizedString, kUndetectableString
   };
 
   /** Allocates a new string from UTF-8 data.*/
   static Local<String> NewFromUtf8(Isolate* isolate,
                                   const char* data,
                                   NewStringType type = kNormalString,
                                   int length = -1);
 
@@ skipping 20 matching lines @@
   /**
    * Creates a new external string using the data defined in the given
    * resource. When the external string is no longer live on V8's heap the
    * resource will be disposed by calling its Dispose method. The caller of
    * this function should not otherwise delete or modify the resource. Neither
    * should the underlying buffer be deallocated or modified except through the
    * destructor of the external string resource.
    */
   static Local<String> NewExternal(Isolate* isolate,
                                    ExternalStringResource* resource);
-  V8_DEPRECATED("Will be removed", static Local<String> NewExternal(
-                                        ExternalStringResource* resource));
 
   /**
    * Associate an external string resource with this string by transforming it
    * in place so that existing references to this string in the JavaScript heap
    * will use the external string resource. The external string resource's
    * character contents need to be equivalent to this string.
    * Returns true if the string has been changed to be an external string.
    * The string is not modified if the operation fails. See NewExternal for
    * information on the lifetime of the resource.
    */
   bool MakeExternal(ExternalStringResource* resource);
 
   /**
    * Creates a new external string using the ASCII data defined in the given
    * resource. When the external string is no longer live on V8's heap the
    * resource will be disposed by calling its Dispose method. The caller of
    * this function should not otherwise delete or modify the resource. Neither
    * should the underlying buffer be deallocated or modified except through the
    * destructor of the external string resource.
    */
   static Local<String> NewExternal(Isolate* isolate,
                                    ExternalAsciiStringResource* resource);
-  V8_DEPRECATED("Will be removed", static Local<String> NewExternal(
-                                        ExternalAsciiStringResource* resource));
 
   /**
    * Associate an external string resource with this string by transforming it
    * in place so that existing references to this string in the JavaScript heap
    * will use the external string resource. The external string resource's
    * character contents need to be equivalent to this string.
    * Returns true if the string has been changed to be an external string.
    * The string is not modified if the operation fails. See NewExternal for
    * information on the lifetime of the resource.
    */
   bool MakeExternal(ExternalAsciiStringResource* resource);
 
   /**
    * Returns true if this string can be made external.
    */
   bool CanMakeExternal();
 
-  /** Creates an undetectable string from the supplied ASCII or UTF-8 data.*/
-  V8_DEPRECATED(
-      "Use NewFromUtf8 instead",
-      V8_INLINE static Local<String> NewUndetectable(const char* data,
-                                                     int length = -1));
-
-  /** Creates an undetectable string from the supplied 16-bit character codes.*/
-  V8_DEPRECATED(
-      "Use NewFromTwoByte instead",
-      V8_INLINE static Local<String> NewUndetectable(const uint16_t* data,
-                                                     int length = -1));
-
   /**
    * Converts an object to a UTF-8-encoded character array.  Useful if
    * you want to print the object.  If conversion to a string fails
    * (e.g. due to an exception in the toString() method of the object)
    * then the length() method returns 0 and the * operator returns
    * NULL.
    */
   class V8_EXPORT Utf8Value {
    public:
     explicit Utf8Value(Handle<v8::Value> obj);
     ~Utf8Value();
     char* operator*() { return str_; }
     const char* operator*() const { return str_; }
     int length() const { return length_; }
    private:
     char* str_;
     int length_;
 
     // Disallow copying and assigning.
     Utf8Value(const Utf8Value&);
     void operator=(const Utf8Value&);
   };
 
   /**
-   * Converts an object to an ASCII string.
-   * Useful if you want to print the object.
-   * If conversion to a string fails (eg. due to an exception in the toString()
-   * method of the object) then the length() method returns 0 and the * operator
-   * returns NULL.
-   */
-  class V8_EXPORT AsciiValue {
-   public:
-    V8_DEPRECATED("Use Utf8Value instead",
-                  explicit AsciiValue(Handle<v8::Value> obj));
-    ~AsciiValue();
-    char* operator*() { return str_; }
-    const char* operator*() const { return str_; }
-    int length() const { return length_; }
-   private:
-    char* str_;
-    int length_;
-
-    // Disallow copying and assigning.
-    AsciiValue(const AsciiValue&);
-    void operator=(const AsciiValue&);
-  };
-
-  /**
    * Converts an object to a two-byte string.
    * If conversion to a string fails (eg. due to an exception in the toString()
    * method of the object) then the length() method returns 0 and the * operator
    * returns NULL.
    */
   class V8_EXPORT Value {
    public:
     explicit Value(Handle<v8::Value> obj);
     ~Value();
     uint16_t* operator*() { return str_; }
@@ skipping 460 matching lines @@
    * Clones an element at index |index|.  Returns an empty
    * handle if cloning fails (for any reason).
    */
   Local<Object> CloneElementAt(uint32_t index);
 
   /**
    * Creates a JavaScript array with the given length. If the length
    * is negative the returned array will have length 0.
    */
   static Local<Array> New(Isolate* isolate, int length = 0);
-  V8_DEPRECATED("Will be removed", static Local<Array> New(int length = 0));
 
   V8_INLINE static Array* Cast(Value* obj);
  private:
   Array();
   static void CheckCast(Value* obj);
 };
 
 
 template<typename T>
 class ReturnValue {
@@ skipping 148 matching lines @@
    * kLineOffsetNotFound if no information available.
    */
   int GetScriptColumnNumber() const;
 
   /**
    * Tells whether this function is builtin.
    */
   bool IsBuiltin() const;
 
   /**
-   * Returns scriptId object.
-   */
-  V8_DEPRECATED("Use ScriptId instead", Handle<Value> GetScriptId() const);
-
-  /**
    * Returns scriptId.
    */
   int ScriptId() const;
 
+  /**
+   * Returns the original function if this function is bound, else returns
+   * v8::Undefined.
+   */
+  Local<Value> GetBoundFunction() const;
+
   ScriptOrigin GetScriptOrigin() const;
   V8_INLINE static Function* Cast(Value* obj);
   static const int kLineOffsetNotFound;
 
  private:
   Function();
   static void CheckCast(Value* obj);
 };
 
 #ifndef V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT
@@ skipping 66 matching lines @@
    */
   size_t ByteLength() const;
 
   /**
    * Create a new ArrayBuffer. Allocate |byte_length| bytes.
    * Allocated memory will be owned by a created ArrayBuffer and
    * will be deallocated when it is garbage-collected,
    * unless the object is externalized.
    */
   static Local<ArrayBuffer> New(Isolate* isolate, size_t byte_length);
-  V8_DEPRECATED("Will be removed",
-                static Local<ArrayBuffer> New(size_t byte_length));
 
   /**
    * Create a new ArrayBuffer over an existing memory block.
    * The created array buffer is immediately in externalized state.
    * The memory block will not be reclaimed when a created ArrayBuffer
    * is garbage-collected.
    */
   static Local<ArrayBuffer> New(Isolate* isolate, void* data,
                                 size_t byte_length);
-  V8_DEPRECATED("Will be removed",
-                static Local<ArrayBuffer> New(void* data, size_t byte_length));
 
   /**
    * Returns true if ArrayBuffer is extrenalized, that is, does not
    * own its memory block.
    */
   bool IsExternal() const;
 
   /**
    * Neuters this ArrayBuffer and all its views (typed arrays).
    * Neutering sets the byte length of the buffer and all typed arrays to zero,
@@ skipping 240 matching lines @@
   static void CheckCast(Value* obj);
 };
 
 
 /**
  * An instance of the built-in Date constructor (ECMA-262, 15.9).
  */
 class V8_EXPORT Date : public Object {
  public:
   static Local<Value> New(Isolate* isolate, double time);
-  V8_DEPRECATED("Will be removed", static Local<Value> New(double time));
-
-  V8_DEPRECATED(
-      "Use ValueOf instead",
-      double NumberValue() const) { return ValueOf(); }
 
   /**
    * A specialization of Value::NumberValue that is more efficient
    * because we know the structure of this object.
    */
   double ValueOf() const;
 
   V8_INLINE static Date* Cast(v8::Value* obj);
 
   /**
    * Notification that the embedder has changed the time zone,
    * daylight savings time, or other date / time configuration
    * parameters.  V8 keeps a cache of various values used for
    * date / time computation.  This notification will reset
    * those cached values for the current context so that date /
    * time configuration changes would be reflected in the Date
    * object.
    *
    * This API should not be called more than needed as it will
    * negatively impact the performance of date operations.
    */
   static void DateTimeConfigurationChangeNotification(Isolate* isolate);
-  V8_DEPRECATED("Will be removed",
-                static void DateTimeConfigurationChangeNotification());
 
  private:
   static void CheckCast(v8::Value* obj);
 };
 
 
 /**
  * A Number object (ECMA-262, 4.3.21).
  */
 class V8_EXPORT NumberObject : public Object {
  public:
   static Local<Value> New(Isolate* isolate, double value);
-  V8_DEPRECATED("Will be removed", static Local<Value> New(double value));
 
-  V8_DEPRECATED(
-      "Use ValueOf instead",
-      double NumberValue() const) { return ValueOf(); }
-
-  /**
-   * Returns the Number held by the object.
-   */
   double ValueOf() const;
 
   V8_INLINE static NumberObject* Cast(v8::Value* obj);
 
  private:
   static void CheckCast(v8::Value* obj);
 };
 
 
 /**
  * A Boolean object (ECMA-262, 4.3.15).
  */
 class V8_EXPORT BooleanObject : public Object {
  public:
   static Local<Value> New(bool value);
 
-  V8_DEPRECATED(
-      "Use ValueOf instead",
-      bool BooleanValue() const) { return ValueOf(); }
-
-  /**
-   * Returns the Boolean held by the object.
-   */
   bool ValueOf() const;
 
   V8_INLINE static BooleanObject* Cast(v8::Value* obj);
 
  private:
   static void CheckCast(v8::Value* obj);
 };
 
 
 /**
  * A String object (ECMA-262, 4.3.18).
  */
 class V8_EXPORT StringObject : public Object {
  public:
   static Local<Value> New(Handle<String> value);
 
-  V8_DEPRECATED(
-      "Use ValueOf instead",
-      Local<String> StringValue() const) { return ValueOf(); }
-
-  /**
-   * Returns the String held by the object.
-   */
   Local<String> ValueOf() const;
 
   V8_INLINE static StringObject* Cast(v8::Value* obj);
 
  private:
   static void CheckCast(v8::Value* obj);
 };
 
 
 /**
  * A Symbol object (ECMA-262 edition 6).
  *
  * This is an experimental feature. Use at your own risk.
  */
 class V8_EXPORT SymbolObject : public Object {
  public:
   static Local<Value> New(Isolate* isolate, Handle<Symbol> value);
 
-  V8_DEPRECATED(
-      "Use ValueOf instead",
-      Local<Symbol> SymbolValue() const) { return ValueOf(); }
-
-  /**
-   * Returns the Symbol held by the object.
-   */
   Local<Symbol> ValueOf() const;
 
   V8_INLINE static SymbolObject* Cast(v8::Value* obj);
 
  private:
   static void CheckCast(v8::Value* obj);
 };
 
 
 /**
@@ skipping 42 matching lines @@
 };
 
 
 /**
  * A JavaScript value that wraps a C++ void*. This type of value is mainly used
  * to associate C++ data structures with JavaScript objects.
  */
 class V8_EXPORT External : public Value {
  public:
   static Local<External> New(Isolate* isolate, void* value);
-  V8_DEPRECATED("Will be removed", static Local<External> New(void *value));
   V8_INLINE static External* Cast(Value* obj);
   void* Value() const;
  private:
   static void CheckCast(v8::Value* obj);
 };
 
 
 // --- Templates ---
 
 
 /**
  * The superclass of object and function templates.
  */
 class V8_EXPORT Template : public Data {
  public:
   /** Adds a property to each instance created by this template.*/
   void Set(Handle<String> name, Handle<Data> value,
            PropertyAttribute attributes = None);
   V8_INLINE void Set(Isolate* isolate, const char* name, Handle<Data> value);
-  V8_DEPRECATED("Will be removed",
-                V8_INLINE void Set(const char* name, Handle<Data> value));
 
   void SetAccessorProperty(
      Local<String> name,
      Local<FunctionTemplate> getter = Local<FunctionTemplate>(),
      Local<FunctionTemplate> setter = Local<FunctionTemplate>(),
      PropertyAttribute attribute = None,
      AccessControl settings = DEFAULT);
 
   /**
    * Whenever the property with the given name is accessed on objects
@@ skipping 515 matching lines @@
  * A Signature specifies which receivers and arguments are valid
  * parameters to a function.
  */
 class V8_EXPORT Signature : public Data {
  public:
   static Local<Signature> New(Isolate* isolate,
                               Handle<FunctionTemplate> receiver =
                                   Handle<FunctionTemplate>(),
                               int argc = 0,
                               Handle<FunctionTemplate> argv[] = 0);
-  V8_DEPRECATED("Will be removed",
-                static Local<Signature> New(Handle<FunctionTemplate> receiver =
-                                                Handle<FunctionTemplate>(),
-                                            int argc = 0,
-                                            Handle<FunctionTemplate> argv[] =
-                                                0));
 
  private:
   Signature();
 };
 
 
 /**
  * An AccessorSignature specifies which receivers are valid parameters
  * to an accessor callback.
  */
 class V8_EXPORT AccessorSignature : public Data {
  public:
   static Local<AccessorSignature> New(Isolate* isolate,
                                       Handle<FunctionTemplate> receiver =
                                           Handle<FunctionTemplate>());
-  V8_DEPRECATED("Will be removed", static Local<AccessorSignature> New(
-                                       Handle<FunctionTemplate> receiver =
-                                           Handle<FunctionTemplate>()));
 
  private:
   AccessorSignature();
 };
 
 
 class V8_EXPORT DeclaredAccessorDescriptor : public Data {
  private:
   DeclaredAccessorDescriptor();
 };
@@ skipping 86 matching lines @@
   // Note that the strings passed into this constructor must live as long
   // as the Extension itself.
   Extension(const char* name,
             const char* source = 0,
             int dep_count = 0,
             const char** deps = 0,
             int source_length = -1);
   virtual ~Extension() { }
   virtual v8::Handle<v8::FunctionTemplate> GetNativeFunctionTemplate(
       v8::Isolate* isolate, v8::Handle<v8::String> name) {
-#if defined(V8_DEPRECATION_WARNINGS)
-    return v8::Handle<v8::FunctionTemplate>();
-#else
-    return GetNativeFunction(name);
-#endif
-  }
-
-  V8_DEPRECATED("Will be removed",
-                virtual v8::Handle<v8::FunctionTemplate> GetNativeFunction(
-                    v8::Handle<v8::String> name)) {
     return v8::Handle<v8::FunctionTemplate>();
   }
 
   const char* name() const { return name_; }
   size_t source_length() const { return source_length_; }
   const String::ExternalAsciiStringResource* source() const {
     return &source_; }
   int dependency_count() { return dep_count_; }
   const char** dependencies() { return deps_; }
   void set_auto_enable(bool value) { auto_enable_ = value; }
@@ skipping 27 matching lines @@
 };
 
 
 // --- Statics ---
 
 V8_INLINE Handle<Primitive> Undefined(Isolate* isolate);
 V8_INLINE Handle<Primitive> Null(Isolate* isolate);
 V8_INLINE Handle<Boolean> True(Isolate* isolate);
 V8_INLINE Handle<Boolean> False(Isolate* isolate);
 
-V8_DEPRECATED("Will be removed", Handle<Primitive> V8_EXPORT Undefined());
-V8_DEPRECATED("Will be removed", Handle<Primitive> V8_EXPORT Null());
-V8_DEPRECATED("Will be removed", Handle<Boolean> V8_EXPORT True());
-V8_DEPRECATED("Will be removed", Handle<Boolean> V8_EXPORT False());
-
 
 /**
  * A set of constraints that specifies the limits of the runtime's memory use.
  * You must set the heap size before initializing the VM - the size cannot be
  * adjusted after the VM is initialized.
  *
  * If you are using threads then you should hold the V8::Locker lock while
  * setting the stack limit and you must set a non-default stack limit separately
  * for each thread.
  */
 class V8_EXPORT ResourceConstraints {
  public:
   ResourceConstraints();
 
   /**
    * Configures the constraints with reasonable default values based on the
    * capabilities of the current device the VM is running on.
    *
    * \param physical_memory The total amount of physical memory on the current
    *   device, in bytes.
    * \param number_of_processors The number of CPUs available on the current
    *   device.
    */
   void ConfigureDefaults(uint64_t physical_memory,
                          uint32_t number_of_processors);
-  V8_DEPRECATED("Will be removed",
-                void ConfigureDefaults(uint64_t physical_memory));
 
   int max_young_space_size() const { return max_young_space_size_; }
   void set_max_young_space_size(int value) { max_young_space_size_ = value; }
   int max_old_space_size() const { return max_old_space_size_; }
   void set_max_old_space_size(int value) { max_old_space_size_ = value; }
   int max_executable_size() const { return max_executable_size_; }
   void set_max_executable_size(int value) { max_executable_size_ = value; }
   uint32_t* stack_limit() const { return stack_limit_; }
   // Sets an address beyond which the VM's stack may not grow.
   void set_stack_limit(uint32_t* value) { stack_limit_ = value; }
@@ skipping 21 matching lines @@
 
 // --- Exceptions ---
 
 
 typedef void (*FatalErrorCallback)(const char* location, const char* message);
 
 
 typedef void (*MessageCallback)(Handle<Message> message, Handle<Value> error);
 
 
-V8_DEPRECATED(
-    "Use Isolate::ThrowException instead",
-    Handle<Value> V8_EXPORT ThrowException(Handle<Value> exception));
-
 /**
  * Create new error objects by calling the corresponding error object
  * constructor with the message.
  */
 class V8_EXPORT Exception {
  public:
   static Local<Value> RangeError(Handle<String> message);
   static Local<Value> ReferenceError(Handle<String> message);
   static Local<Value> SyntaxError(Handle<String> message);
   static Local<Value> TypeError(Handle<String> message);
@@ skipping 69 matching lines @@
 
 enum GCCallbackFlags {
   kNoGCCallbackFlags = 0,
   kGCCallbackFlagCompacted = 1 << 0,
   kGCCallbackFlagConstructRetainedObjectInfos = 1 << 1
 };
 
 typedef void (*GCPrologueCallback)(GCType type, GCCallbackFlags flags);
 typedef void (*GCEpilogueCallback)(GCType type, GCCallbackFlags flags);
 
+typedef void (*InterruptCallback)(Isolate* isolate, void* data);
+
 
 /**
  * Collection of V8 heap information.
  *
  * Instances of this class can be passed to v8::V8::HeapStatistics to
  * get heap statistics from V8.
  */
 class V8_EXPORT HeapStatistics {
  public:
   HeapStatistics();
@@ skipping 83 matching lines @@
    * Requires: this == Isolate::GetCurrent().
    */
   void Exit();
 
   /**
    * Disposes the isolate.  The isolate must not be entered by any
    * thread to be disposable.
    */
   void Dispose();
 
-  V8_DEPRECATED("Use SetData(0, data) instead.",
-                V8_INLINE void SetData(void* data));
-  V8_DEPRECATED("Use GetData(0) instead.", V8_INLINE void* GetData());
-
   /**
    * Associate embedder-specific data with the isolate. |slot| has to be
    * between 0 and GetNumberOfDataSlots() - 1.
    */
   V8_INLINE void SetData(uint32_t slot, void* data);
 
   /**
    * Retrieve embedder-specific data from the isolate.
    * Returns NULL if SetData has never been called for the given |slot|.
    */
@@ skipping 133 matching lines @@
    */
   void AddGCEpilogueCallback(
       GCEpilogueCallback callback, GCType gc_type_filter = kGCTypeAll);
 
   /**
    * This function removes callback which was installed by
    * AddGCEpilogueCallback function.
    */
   void RemoveGCEpilogueCallback(GCEpilogueCallback callback);
 
+  /**
+   * Request V8 to interrupt long running JavaScript code and invoke
+   * the given |callback| passing the given |data| to it. After |callback|
+   * returns control will be returned to the JavaScript code.
+   * At any given moment V8 can remember only a single callback for the very
+   * last interrupt request.
+   * Can be called from another thread without acquiring a |Locker|.
+   * Registered |callback| must not reenter interrupted Isolate.
+   */
+  void RequestInterrupt(InterruptCallback callback, void* data);
+
+  /**
+   * Clear interrupt request created by |RequestInterrupt|.
+   * Can be called from another thread without acquiring a |Locker|.
+   */
+  void ClearInterrupt();
+
  private:
   Isolate();
   Isolate(const Isolate&);
   ~Isolate();
   Isolate& operator=(const 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);
@@ skipping 444 matching lines @@
    *     are not guaranteed to live past each call. The \p event_handler must
    *     copy strings and other parameters it needs to keep around.
    * \note the set of events declared in JitCodeEvent::EventType is expected to
    *     grow over time, and the JitCodeEvent structure is expected to accrue
    *     new members. The \p event_handler function must ignore event codes
    *     it does not recognize to maintain future compatibility.
    */
   static void SetJitCodeEventHandler(JitCodeEventOptions options,
                                      JitCodeEventHandler event_handler);
 
-  V8_DEPRECATED(
-      "Use Isolate::AdjustAmountOfExternalAllocatedMemory instead",
-      static int64_t AdjustAmountOfExternalAllocatedMemory(
-          int64_t change_in_bytes));
-
   /**
    * Forcefully terminate the current thread of JavaScript execution
    * in the given isolate. If no isolate is provided, the default
    * isolate is used.
    *
    * This method can be used by any thread even if that thread has not
    * acquired the V8 lock with a Locker object.
    *
    * \param isolate The isolate in which to terminate the current JS execution.
    */
@@ skipping 109 matching lines @@
    */
   static void ShutdownPlatform();
 
  private:
   V8();
 
   static internal::Object** GlobalizeReference(internal::Isolate* isolate,
                                                internal::Object** handle);
   static internal::Object** CopyPersistent(internal::Object** handle);
   static void DisposeGlobal(internal::Object** global_handle);
-  typedef WeakReferenceCallbacks<Value, void>::Revivable RevivableCallback;
   typedef WeakCallbackData<Value, void>::Callback WeakCallback;
   static void MakeWeak(internal::Object** global_handle,
                        void* data,
-                       WeakCallback weak_callback,
-                       RevivableCallback weak_reference_callback);
+                       WeakCallback weak_callback);
   static void ClearWeak(internal::Object** global_handle);
   static void Eternalize(Isolate* isolate,
                          Value* handle,
                          int* index);
   static Local<Value> GetEternal(Isolate* isolate, int index);
 
   template <class T> friend class Handle;
   template <class T> friend class Local;
   template <class T> friend class Eternal;
   template <class T> friend class PersistentBase;
@@ skipping 149 matching lines @@
 };
 
 
 /**
  * A sandboxed execution context with its own set of built-in objects
  * and functions.
  */
 class V8_EXPORT Context {
  public:
   /**
-   * Returns the global proxy object or global object itself for
-   * detached contexts.
+   * Returns the global proxy object.
    *
-   * Global proxy object is a thin wrapper whose prototype points to
-   * actual context's global object with the properties like Object, etc.
-   * This is done that way for security reasons (for more details see
+   * Global proxy object is a thin wrapper whose prototype points to actual
+   * context's global object with the properties like Object, etc. This is done
+   * that way for security reasons (for more details see
    * https://wiki.mozilla.org/Gecko:SplitWindow).
    *
    * Please note that changes to global proxy object prototype most probably
-   * would break VM---v8 expects only global object as a prototype of
-   * global proxy object.
-   *
-   * If DetachGlobal() has been invoked, Global() would return actual global
-   * object until global is reattached with ReattachGlobal().
+   * would break VM---v8 expects only global object as a prototype of global
+   * proxy object.
    */
   Local<Object> Global();
 
   /**
    * Detaches the global object from its context before
    * the global object can be reused to create a new context.
    */
   void DetachGlobal();
 
   /**
-   * Reattaches a global object to a context.  This can be used to
-   * restore the connection between a global object and a context
-   * after DetachGlobal has been called.
-   *
-   * \param global_object The global object to reattach to the
-   *   context.  For this to work, the global object must be the global
-   *   object that was associated with this context before a call to
-   *   DetachGlobal.
-   */
-  void ReattachGlobal(Handle<Object> global_object);
-
-  /**
    * Creates a new context and returns a handle to the newly allocated
    * context.
    *
    * \param isolate The isolate in which to create the context.
    *
    * \param extensions An optional extension configuration containing
    * the extensions to be installed in the newly created context.
    *
    * \param global_template An optional object template from which the
    * global object for the newly created context will be created.
    *
    * \param global_object An optional global object to be reused for
    * the newly created context. This global object must have been
    * created by a previous call to Context::New with the same global
    * template. The state of the global object will be completely reset
    * and only object identify will remain.
    */
   static Local<Context> New(
       Isolate* isolate,
       ExtensionConfiguration* extensions = NULL,
       Handle<ObjectTemplate> global_template = Handle<ObjectTemplate>(),
       Handle<Value> global_object = Handle<Value>());
 
-  V8_DEPRECATED("Use Isolate::GetEnteredContext instead",
-                static Local<Context> GetEntered());
-
-  V8_DEPRECATED("Use Isolate::GetCurrentContext instead",
-                static Local<Context> GetCurrent());
-
-  V8_DEPRECATED("Use Isolate::GetCallingContext instead",
-                static Local<Context> GetCalling());
-
   /**
    * Sets the security token for the context.  To access an object in
    * another context, the security tokens must match.
    */
   void SetSecurityToken(Handle<Value> token);
 
   /** Restores the security token to the default value. */
   void UseDefaultSecurityToken();
 
   /** Returns the security token of this context.*/
   Handle<Value> GetSecurityToken();
 
   /**
    * Enter this context.  After entering a context, all code compiled
    * and run is compiled and run in this context.  If another context
    * is already entered, this old context is saved so it can be
    * restored when the new context is exited.
    */
   void Enter();
 
   /**
    * Exit this context.  Exiting the current context restores the
    * context that was in place when entering the current context.
    */
   void Exit();
 
   /** Returns true if the context has experienced an out of memory situation. */
   bool HasOutOfMemoryException();
 
-  V8_DEPRECATED("Use Isolate::InContext instead",
-                static bool InContext());
-
   /** Returns an isolate associated with a current context. */
   v8::Isolate* GetIsolate();
 
   /**
    * Gets the embedder data with the given index, which must have been set by a
    * previous call to SetEmbedderData with the same index. Note that index 0
    * currently has a special meaning for Chrome's debugger.
    */
   V8_INLINE Local<Value> GetEmbedderData(int index);
 
@@ skipping 49 matching lines @@
 
   /**
    * Stack-allocated class which sets the execution context for all
    * operations executed within a local scope.
    */
   class Scope {
    public:
     explicit V8_INLINE Scope(Handle<Context> context) : context_(context) {
       context_->Enter();
     }
-    V8_DEPRECATED(
-        "Use Handle version instead",
-        V8_INLINE Scope(Isolate* isolate, Persistent<Context>& context)) // NOLINT
-    : context_(Handle<Context>::New(isolate, context)) {
-      context_->Enter();
-    }
     V8_INLINE ~Scope() { context_->Exit(); }
 
    private:
     Handle<Context> context_;
   };
 
  private:
   friend class Value;
   friend class Script;
   friend class Object;
@@ skipping 294 matching lines @@
   static const int kStringEncodingMask = 0x4;
   static const int kExternalTwoByteRepresentationTag = 0x02;
   static const int kExternalAsciiRepresentationTag = 0x06;
 
   static const int kIsolateEmbedderDataOffset = 0 * kApiPointerSize;
   static const int kIsolateRootsOffset = 5 * 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 = 134;
+  static const int kEmptyStringRootIndex = 135;
 
   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 kNodeStateIsPendingValue = 3;
   static const int kNodeStateIsNearDeathValue = 4;
   static const int kNodeIsIndependentShift = 4;
   static const int kNodeIsPartiallyDependentShift = 5;
 
@@ skipping 250 matching lines @@
 
 template <class T>
 template <typename S, typename P>
 void PersistentBase<T>::SetWeak(
     P* parameter,
     typename WeakCallbackData<S, P>::Callback callback) {
   TYPE_CHECK(S, T);
   typedef typename WeakCallbackData<Value, void>::Callback Callback;
   V8::MakeWeak(reinterpret_cast<internal::Object**>(this->val_),
                parameter,
-               reinterpret_cast<Callback>(callback),
-               NULL);
+               reinterpret_cast<Callback>(callback));
 }
 
 
 template <class T>
 template <typename P>
 void PersistentBase<T>::SetWeak(
     P* parameter,
     typename WeakCallbackData<T, P>::Callback callback) {
   SetWeak<T, P>(parameter, callback);
 }
 
 
-template <class T, class M>
-template <typename S, typename P>
-void Persistent<T, M>::MakeWeak(
-    P* parameters,
-    typename WeakReferenceCallbacks<S, P>::Revivable callback) {
-  TYPE_CHECK(S, T);
-  typedef typename WeakReferenceCallbacks<Value, void>::Revivable Revivable;
-  V8::MakeWeak(reinterpret_cast<internal::Object**>(this->val_),
-               parameters,
-               NULL,
-               reinterpret_cast<Revivable>(callback));
-}
-
-
-template <class T, class M>
-template <typename P>
-void Persistent<T, M>::MakeWeak(
-    P* parameters,
-    typename WeakReferenceCallbacks<T, P>::Revivable callback) {
-  MakeWeak<T, P>(parameters, callback);
-}
-
-
 template <class T>
 void PersistentBase<T>::ClearWeak() {
   V8::ClearWeak(reinterpret_cast<internal::Object**>(this->val_));
 }
 
 
 template <class T>
 void PersistentBase<T>::MarkIndependent() {
   typedef internal::Internals I;
   if (this->IsEmpty()) return;
@@ skipping 204 matching lines @@
   return is_construct_call_;
 }
 
 
 template<typename T>
 int FunctionCallbackInfo<T>::Length() const {
   return length_;
 }
 
 
-template <class T>
-Local<T> HandleScope::Close(Handle<T> value) {
-  internal::Object** before = reinterpret_cast<internal::Object**>(*value);
-  internal::Object** after = RawClose(before);
-  return Local<T>(reinterpret_cast<T*>(after));
-}
-
 Handle<Value> ScriptOrigin::ResourceName() const {
   return resource_name_;
 }
 
 
 Handle<Integer> ScriptOrigin::ResourceLineOffset() const {
   return resource_line_offset_;
 }
 
 
 Handle<Integer> ScriptOrigin::ResourceColumnOffset() const {
   return resource_column_offset_;
 }
 
 Handle<Boolean> ScriptOrigin::ResourceIsSharedCrossOrigin() const {
   return resource_is_shared_cross_origin_;
 }
 
 
 Handle<Boolean> Boolean::New(Isolate* isolate, bool value) {
   return value ? True(isolate) : False(isolate);
 }
 
 
-Handle<Boolean> Boolean::New(bool value) {
-  return Boolean::New(Isolate::GetCurrent(), value);
-}
-
-
 void Template::Set(Isolate* isolate, const char* name, v8::Handle<Data> value) {
   Set(v8::String::NewFromUtf8(isolate, name), value);
 }
 
 
-void Template::Set(const char* name, v8::Handle<Data> value) {
-  Set(Isolate::GetCurrent(), name, value);
-}
-
-
 Local<Value> Object::GetInternalField(int index) {
 #ifndef V8_ENABLE_CHECKS
   typedef internal::Object O;
   typedef internal::HeapObject HO;
   typedef internal::Internals I;
   O* obj = *reinterpret_cast<O**>(this);
   // Fast path: If the object is a plain JSObject, which is the common case, we
   // know where to find the internal fields and can return the value directly.
   if (I::GetInstanceType(obj) == I::kJSObjectType) {
     int offset = I::kJSObjectHeaderSize + (internal::kApiPointerSize * index);
@@ skipping 32 matching lines @@
 
 Local<String> String::Empty(Isolate* isolate) {
   typedef internal::Object* S;
   typedef internal::Internals I;
   I::CheckInitialized(isolate);
   S* slot = I::GetRoot(isolate, I::kEmptyStringRootIndex);
   return Local<String>(reinterpret_cast<String*>(slot));
 }
 
 
-Local<String> String::New(const char* data, int length) {
-  return NewFromUtf8(Isolate::GetCurrent(), data, kNormalString, length);
-}
-
-
-Local<String> String::New(const uint16_t* data, int length) {
-  return NewFromTwoByte(Isolate::GetCurrent(), data, kNormalString, length);
-}
-
-
-Local<String> String::NewSymbol(const char* data, int length) {
-  return NewFromUtf8(Isolate::GetCurrent(), data, kInternalizedString, length);
-}
-
-
-Local<String> String::NewUndetectable(const char* data, int length) {
-  return NewFromUtf8(Isolate::GetCurrent(), data, kUndetectableString, length);
-}
-
-
-Local<String> String::NewUndetectable(const uint16_t* data, int length) {
-  return NewFromTwoByte(
-      Isolate::GetCurrent(), data, kUndetectableString, length);
-}
-
-
 String::ExternalStringResource* String::GetExternalStringResource() const {
   typedef internal::Object O;
   typedef internal::Internals I;
   O* obj = *reinterpret_cast<O**>(const_cast<String*>(this));
   String::ExternalStringResource* result;
   if (I::IsExternalTwoByteString(I::GetInstanceType(obj))) {
     void* value = I::ReadField<void*>(obj, I::kStringResourceOffset);
     result = reinterpret_cast<String::ExternalStringResource*>(value);
   } else {
     result = NULL;
@@ skipping 350 matching lines @@
 
 Handle<Boolean> False(Isolate* isolate) {
   typedef internal::Object* S;
   typedef internal::Internals I;
   I::CheckInitialized(isolate);
   S* slot = I::GetRoot(isolate, I::kFalseValueRootIndex);
   return Handle<Boolean>(reinterpret_cast<Boolean*>(slot));
 }
 
 
-void Isolate::SetData(void* data) {
-  typedef internal::Internals I;
-  I::SetEmbedderData(this, 0, data);
-}
-
-
-void* Isolate::GetData() {
-  typedef internal::Internals I;
-  return I::GetEmbedderData(this, 0);
-}
-
-
 void Isolate::SetData(uint32_t slot, void* data) {
   typedef internal::Internals I;
   I::SetEmbedderData(this, slot, data);
 }
 
 
 void* Isolate::GetData(uint32_t slot) {
   typedef internal::Internals I;
   return I::GetEmbedderData(this, slot);
 }
@@ skipping 69 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_