Update V8 to version 4.1.0.21
This is a cherry-pick of all commits up to and including the
4.1.0.21 cherry-pick in Chromium.
Original commit message:
Version 4.1.0.21 (cherry-pick)
Merged 206e9136bde0f2b5ae8cb77afbb1e7833e5bd412
Unlink pages from the space page list after evacuation.
BUG=430201
LOG=N
R=jkummerow@chromium.org
Review URL: https://codereview.chromium.org/953813002
Cr-Commit-Position: refs/branch-heads/4.1@{#22}
Cr-Branched-From: 2e08d2a7aa9d65d269d8c57aba82eb38a8cb0a18-refs/heads/candidates@{#25353}
---
FPIIM-449
Change-Id: I8c23c7bbb70772b4858fe8a47b64fa97ee0d1f8c
diff --git a/include/v8.h b/include/v8.h
index ec1941e..b445525 100644
--- a/include/v8.h
+++ b/include/v8.h
@@ -15,7 +15,11 @@
#ifndef V8_H_
#define V8_H_
-#include "v8stdint.h"
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#include "v8config.h"
// We reserve the V8_* prefix for macros defined in V8 public API and
// assume there are no name conflicts with the embedder's code.
@@ -85,6 +89,7 @@
class ObjectTemplate;
class Platform;
class Primitive;
+class Promise;
class RawOperationDescriptor;
class Script;
class Signature;
@@ -135,6 +140,17 @@
class PropertyCallbackArguments;
class FunctionCallbackArguments;
class GlobalHandles;
+
+class CallbackData {
+ public:
+ V8_INLINE v8::Isolate* GetIsolate() const { return isolate_; }
+
+ protected:
+ explicit CallbackData(v8::Isolate* isolate) : isolate_(isolate) {}
+
+ private:
+ v8::Isolate* isolate_;
+};
}
@@ -413,22 +429,53 @@
};
-template<class T, class P>
-class WeakCallbackData {
+template <typename T>
+class PhantomCallbackData : public internal::CallbackData {
+ public:
+ typedef void (*Callback)(const PhantomCallbackData<T>& data);
+
+ V8_INLINE T* GetParameter() const { return parameter_; }
+
+ PhantomCallbackData<T>(Isolate* isolate, T* parameter)
+ : internal::CallbackData(isolate), parameter_(parameter) {}
+
+ private:
+ T* parameter_;
+};
+
+
+template <class T, class P>
+class WeakCallbackData : public PhantomCallbackData<P> {
public:
typedef void (*Callback)(const WeakCallbackData<T, P>& data);
- V8_INLINE Isolate* GetIsolate() const { return isolate_; }
V8_INLINE Local<T> GetValue() const { return handle_; }
- V8_INLINE P* GetParameter() const { return parameter_; }
private:
friend class internal::GlobalHandles;
- WeakCallbackData(Isolate* isolate, Local<T> handle, P* parameter)
- : isolate_(isolate), handle_(handle), parameter_(parameter) { }
- Isolate* isolate_;
+ WeakCallbackData(Isolate* isolate, P* parameter, Local<T> handle)
+ : PhantomCallbackData<P>(isolate, parameter), handle_(handle) {}
Local<T> handle_;
- P* parameter_;
+};
+
+
+template <typename T, typename U>
+class InternalFieldsCallbackData : public internal::CallbackData {
+ public:
+ typedef void (*Callback)(const InternalFieldsCallbackData<T, U>& data);
+
+ InternalFieldsCallbackData(Isolate* isolate, T* internalField1,
+ U* internalField2)
+ : internal::CallbackData(isolate),
+ internal_field1_(internalField1),
+ internal_field2_(internalField2) {}
+
+ V8_INLINE T* GetInternalField1() const { return internal_field1_; }
+ V8_INLINE U* GetInternalField2() const { return internal_field2_; }
+
+ private:
+ T* internal_field1_;
+ U* internal_field2_;
};
@@ -466,22 +513,23 @@
template <class S>
V8_INLINE void Reset(Isolate* isolate, const PersistentBase<S>& other);
- V8_INLINE bool IsEmpty() const { return val_ == 0; }
+ V8_INLINE bool IsEmpty() const { return val_ == NULL; }
+ V8_INLINE void Empty() { val_ = 0; }
template <class S>
V8_INLINE bool operator==(const PersistentBase<S>& that) const {
internal::Object** a = reinterpret_cast<internal::Object**>(this->val_);
internal::Object** b = reinterpret_cast<internal::Object**>(that.val_);
- if (a == 0) return b == 0;
- if (b == 0) return false;
+ if (a == NULL) return b == NULL;
+ if (b == NULL) return false;
return *a == *b;
}
template <class S> V8_INLINE bool operator==(const Handle<S>& that) const {
internal::Object** a = reinterpret_cast<internal::Object**>(this->val_);
internal::Object** b = reinterpret_cast<internal::Object**>(that.val_);
- if (a == 0) return b == 0;
- if (b == 0) return false;
+ if (a == NULL) return b == NULL;
+ if (b == NULL) return false;
return *a == *b;
}
@@ -511,6 +559,21 @@
P* parameter,
typename WeakCallbackData<S, P>::Callback callback);
+ // Phantom persistents work like weak persistents, except that the pointer to
+ // the object being collected is not available in the finalization callback.
+ // This enables the garbage collector to collect the object and any objects
+ // it references transitively in one GC cycle. At the moment you can either
+ // specify a parameter for the callback or the location of two internal
+ // fields in the dying object.
+ template <typename P>
+ V8_INLINE void SetPhantom(P* parameter,
+ typename PhantomCallbackData<P>::Callback callback);
+
+ template <typename P, typename Q>
+ V8_INLINE void SetPhantom(
+ void (*callback)(const InternalFieldsCallbackData<P, Q>&),
+ int internal_field_index1, int internal_field_index2);
+
template<typename P>
V8_INLINE P* ClearWeak();
@@ -696,9 +759,6 @@
return Persistent<S>::Cast(*this);
}
- // This will be removed.
- V8_INLINE T* ClearAndLeak();
-
private:
friend class Isolate;
friend class Utils;
@@ -997,7 +1057,7 @@
/**
* Runs the script returning the resulting value. It will be run in the
* context in which it was created (ScriptCompiler::CompileBound or
- * UnboundScript::BindToGlobalContext()).
+ * UnboundScript::BindToCurrentContext()).
*/
Local<Value> Run();
@@ -1031,7 +1091,11 @@
BufferOwned
};
- CachedData() : data(NULL), length(0), buffer_policy(BufferNotOwned) {}
+ CachedData()
+ : data(NULL),
+ length(0),
+ rejected(false),
+ buffer_policy(BufferNotOwned) {}
// If buffer_policy is BufferNotOwned, the caller keeps the ownership of
// data and guarantees that it stays alive until the CachedData object is
@@ -1044,6 +1108,7 @@
// which will be called when V8 no longer needs the data.
const uint8_t* data;
int length;
+ bool rejected;
BufferPolicy buffer_policy;
private:
@@ -1224,6 +1289,26 @@
static Local<Script> Compile(Isolate* isolate, StreamedSource* source,
Handle<String> full_source_string,
const ScriptOrigin& origin);
+
+ /**
+ * Return a version tag for CachedData for the current V8 version & flags.
+ *
+ * This value is meant only for determining whether a previously generated
+ * CachedData instance is still valid; the tag has no other meaing.
+ *
+ * Background: The data carried by CachedData may depend on the exact
+ * V8 version number or currently compiler flags. This means when
+ * persisting CachedData, the embedder must take care to not pass in
+ * data from another V8 version, or the same version with different
+ * features enabled.
+ *
+ * The easiest way to do so is to clear the embedder's cache on any
+ * such change.
+ *
+ * Alternatively, this tag can be stored alongside the cached data and
+ * compared when it is being used.
+ */
+ static uint32_t CachedDataVersionTag();
};
@@ -1415,6 +1500,27 @@
};
+// A StateTag represents a possible state of the VM.
+enum StateTag { JS, GC, COMPILER, OTHER, EXTERNAL, IDLE };
+
+
+// A RegisterState represents the current state of registers used
+// by the sampling profiler API.
+struct RegisterState {
+ RegisterState() : pc(NULL), sp(NULL), fp(NULL) {}
+ void* pc; // Instruction pointer.
+ void* sp; // Stack pointer.
+ void* fp; // Frame pointer.
+};
+
+
+// The output structure filled up by GetStackSample API function.
+struct SampleInfo {
+ size_t frames_count;
+ StateTag vm_state;
+};
+
+
/**
* A JSON Parser.
*/
@@ -1561,6 +1667,18 @@
bool IsRegExp() const;
/**
+ * Returns true if this value is a Generator function.
+ * This is an experimental feature.
+ */
+ bool IsGeneratorFunction() const;
+
+ /**
+ * Returns true if this value is a Generator object (iterator).
+ * This is an experimental feature.
+ */
+ bool IsGeneratorObject() const;
+
+ /**
* Returns true if this value is a Promise.
* This is an experimental feature.
*/
@@ -1579,6 +1697,18 @@
bool IsSet() const;
/**
+ * Returns true if this value is a Map Iterator.
+ * This is an experimental feature.
+ */
+ bool IsMapIterator() const;
+
+ /**
+ * Returns true if this value is a Set Iterator.
+ * This is an experimental feature.
+ */
+ bool IsSetIterator() const;
+
+ /**
* Returns true if this value is a WeakMap.
* This is an experimental feature.
*/
@@ -1668,14 +1798,24 @@
*/
bool IsDataView() const;
- Local<Boolean> ToBoolean() const;
- Local<Number> ToNumber() const;
- Local<String> ToString() const;
- Local<String> ToDetailString() const;
- Local<Object> ToObject() const;
- Local<Integer> ToInteger() const;
- Local<Uint32> ToUint32() const;
- Local<Int32> ToInt32() const;
+ Local<Boolean> ToBoolean(Isolate* isolate) const;
+ Local<Number> ToNumber(Isolate* isolate) const;
+ Local<String> ToString(Isolate* isolate) const;
+ Local<String> ToDetailString(Isolate* isolate) const;
+ Local<Object> ToObject(Isolate* isolate) const;
+ Local<Integer> ToInteger(Isolate* isolate) const;
+ Local<Uint32> ToUint32(Isolate* isolate) const;
+ Local<Int32> ToInt32(Isolate* isolate) const;
+
+ // TODO(dcarney): deprecate all these.
+ inline Local<Boolean> ToBoolean() const;
+ inline Local<Number> ToNumber() const;
+ inline Local<String> ToString() const;
+ inline Local<String> ToDetailString() const;
+ inline Local<Object> ToObject() const;
+ inline Local<Integer> ToInteger() const;
+ inline Local<Uint32> ToUint32() const;
+ inline Local<Int32> ToInt32() const;
/**
* Attempts to convert a string to an array index.
@@ -1728,6 +1868,15 @@
*/
class V8_EXPORT Name : public Primitive {
public:
+ /**
+ * Returns the identity hash for this object. The current implementation
+ * uses an inline property on the object to store the identity hash.
+ *
+ * The return value will never be 0. Also, it is not guaranteed to be
+ * unique.
+ */
+ int GetIdentityHash();
+
V8_INLINE static Name* Cast(v8::Value* obj);
private:
static void CheckCast(v8::Value* obj);
@@ -1742,7 +1891,6 @@
enum Encoding {
UNKNOWN_ENCODING = 0x1,
TWO_BYTE_ENCODING = 0x0,
- ASCII_ENCODING = 0x4, // TODO(yangguo): deprecate this.
ONE_BYTE_ENCODING = 0x4
};
/**
@@ -1798,7 +1946,6 @@
NO_OPTIONS = 0,
HINT_MANY_WRITES_EXPECTED = 1,
NO_NULL_TERMINATION = 2,
- PRESERVE_ASCII_NULL = 4, // TODO(yangguo): deprecate this.
PRESERVE_ONE_BYTE_NULL = 4,
// Used by WriteUtf8 to replace orphan surrogate code units with the
// unicode replacement character. Needs to be set to guarantee valid UTF-8
@@ -1837,9 +1984,6 @@
*/
bool IsExternalOneByte() const;
- // TODO(yangguo): deprecate this.
- bool IsExternalAscii() const { return IsExternalOneByte(); }
-
class V8_EXPORT ExternalStringResourceBase { // NOLINT
public:
virtual ~ExternalStringResourceBase() {}
@@ -1918,8 +2062,6 @@
ExternalOneByteStringResource() {}
};
- typedef ExternalOneByteStringResource ExternalAsciiStringResource;
-
/**
* If the string is an external string, return the ExternalStringResourceBase
* regardless of the encoding, otherwise return NULL. The encoding of the
@@ -1940,11 +2082,6 @@
*/
const ExternalOneByteStringResource* GetExternalOneByteStringResource() const;
- // TODO(yangguo): deprecate this.
- const ExternalAsciiStringResource* GetExternalAsciiStringResource() const {
- return GetExternalOneByteStringResource();
- }
-
V8_INLINE static String* Cast(v8::Value* obj);
enum NewStringType {
@@ -2107,6 +2244,7 @@
// Well-known symbols
static Local<Symbol> GetIterator(Isolate* isolate);
static Local<Symbol> GetUnscopables(Isolate* isolate);
+ static Local<Symbol> GetToStringTag(Isolate* isolate);
V8_INLINE static Symbol* Cast(v8::Value* obj);
@@ -2400,6 +2538,8 @@
/** Gets the number of internal fields for this Object. */
int InternalFieldCount();
+ static const int kNoInternalFieldIndex = -1;
+
/** Same as above, but works for Persistents */
V8_INLINE static int InternalFieldCount(
const PersistentBase<Object>& object) {
@@ -2484,15 +2624,6 @@
bool DeleteHiddenValue(Handle<String> key);
/**
- * Returns true if this is an instance of an api function (one
- * created from a function created from a function template) and has
- * been modified since it was created. Note that this method is
- * conservative and may return true for objects that haven't actually
- * been modified.
- */
- bool IsDirty();
-
- /**
* Clone this object with a fast but shallow copy. Values will point
* to the same values as the original object.
*/
@@ -2552,6 +2683,11 @@
*/
Local<Value> CallAsConstructor(int argc, Handle<Value> argv[]);
+ /**
+ * Return the isolate to which the Object belongs to.
+ */
+ Isolate* GetIsolate();
+
static Local<Object> New(Isolate* isolate);
V8_INLINE static Object* Cast(Value* obj);
@@ -2818,6 +2954,12 @@
Local<Promise> Catch(Handle<Function> handler);
Local<Promise> Then(Handle<Function> handler);
+ /**
+ * Returns true if the promise has at least one derived promise, and
+ * therefore resolve/reject handlers (including default handler).
+ */
+ bool HasHandler();
+
V8_INLINE static Promise* Cast(Value* obj);
private:
@@ -2920,10 +3062,15 @@
bool IsExternal() const;
/**
+ * Returns true if this ArrayBuffer may be neutered.
+ */
+ bool IsNeuterable() const;
+
+ /**
* Neuters this ArrayBuffer and all its views (typed arrays).
* Neutering sets the byte length of the buffer and all typed arrays to zero,
* preventing JavaScript from ever accessing underlying backing store.
- * ArrayBuffer should have been externalized.
+ * ArrayBuffer should have been externalized and must be neuterable.
*/
void Neuter();
@@ -3455,6 +3602,51 @@
const PropertyCallbackInfo<Array>& info);
+// TODO(dcarney): Deprecate and remove previous typedefs, and replace
+// GenericNamedPropertyFooCallback with just NamedPropertyFooCallback.
+/**
+ * GenericNamedProperty[Getter|Setter] are used as interceptors on object.
+ * See ObjectTemplate::SetNamedPropertyHandler.
+ */
+typedef void (*GenericNamedPropertyGetterCallback)(
+ Local<Name> property, const PropertyCallbackInfo<Value>& info);
+
+
+/**
+ * Returns the value if the setter intercepts the request.
+ * Otherwise, returns an empty handle.
+ */
+typedef void (*GenericNamedPropertySetterCallback)(
+ Local<Name> property, Local<Value> value,
+ const PropertyCallbackInfo<Value>& info);
+
+
+/**
+ * Returns a non-empty handle if the interceptor intercepts the request.
+ * The result is an integer encoding property attributes (like v8::None,
+ * v8::DontEnum, etc.)
+ */
+typedef void (*GenericNamedPropertyQueryCallback)(
+ Local<Name> property, const PropertyCallbackInfo<Integer>& info);
+
+
+/**
+ * Returns a non-empty handle if the deleter intercepts the request.
+ * The return value is true if the property could be deleted and false
+ * otherwise.
+ */
+typedef void (*GenericNamedPropertyDeleterCallback)(
+ Local<Name> property, const PropertyCallbackInfo<Boolean>& info);
+
+
+/**
+ * Returns an array containing the names of the properties the named
+ * property getter intercepts.
+ */
+typedef void (*GenericNamedPropertyEnumeratorCallback)(
+ const PropertyCallbackInfo<Array>& info);
+
+
/**
* Returns the value of the property if the getter intercepts the
* request. Otherwise, returns an empty handle.
@@ -3707,6 +3899,65 @@
};
+enum class PropertyHandlerFlags { kNone = 0, kAllCanRead = 1 };
+
+
+struct NamedPropertyHandlerConfiguration {
+ NamedPropertyHandlerConfiguration(
+ /** Note: getter is required **/
+ GenericNamedPropertyGetterCallback getter = 0,
+ GenericNamedPropertySetterCallback setter = 0,
+ GenericNamedPropertyQueryCallback query = 0,
+ GenericNamedPropertyDeleterCallback deleter = 0,
+ GenericNamedPropertyEnumeratorCallback enumerator = 0,
+ Handle<Value> data = Handle<Value>(),
+ PropertyHandlerFlags flags = PropertyHandlerFlags::kNone)
+ : getter(getter),
+ setter(setter),
+ query(query),
+ deleter(deleter),
+ enumerator(enumerator),
+ data(data),
+ flags(flags) {}
+
+ GenericNamedPropertyGetterCallback getter;
+ GenericNamedPropertySetterCallback setter;
+ GenericNamedPropertyQueryCallback query;
+ GenericNamedPropertyDeleterCallback deleter;
+ GenericNamedPropertyEnumeratorCallback enumerator;
+ Handle<Value> data;
+ PropertyHandlerFlags flags;
+};
+
+
+struct IndexedPropertyHandlerConfiguration {
+ IndexedPropertyHandlerConfiguration(
+ /** Note: getter is required **/
+ IndexedPropertyGetterCallback getter = 0,
+ IndexedPropertySetterCallback setter = 0,
+ IndexedPropertyQueryCallback query = 0,
+ IndexedPropertyDeleterCallback deleter = 0,
+ IndexedPropertyEnumeratorCallback enumerator = 0,
+ Handle<Value> data = Handle<Value>(),
+ PropertyHandlerFlags flags = PropertyHandlerFlags::kNone)
+ : getter(getter),
+ setter(setter),
+ query(query),
+ deleter(deleter),
+ enumerator(enumerator),
+ data(data),
+ flags(flags) {}
+
+ IndexedPropertyGetterCallback getter;
+ IndexedPropertySetterCallback setter;
+ IndexedPropertyQueryCallback query;
+ IndexedPropertyDeleterCallback deleter;
+ IndexedPropertyEnumeratorCallback enumerator;
+ Handle<Value> data;
+ PropertyHandlerFlags flags;
+};
+
+
/**
* An ObjectTemplate is used to create objects at runtime.
*
@@ -3776,6 +4027,9 @@
* from this object template, the provided callback is invoked instead of
* accessing the property directly on the JavaScript object.
*
+ * Note that new code should use the second version that can intercept
+ * symbol-named properties as well as string-named properties.
+ *
* \param getter The callback to invoke when getting a property.
* \param setter The callback to invoke when setting a property.
* \param query The callback to invoke to check if a property is present,
@@ -3786,6 +4040,7 @@
* \param data A piece of data that will be passed to the callbacks
* whenever they are invoked.
*/
+ // TODO(dcarney): deprecate
void SetNamedPropertyHandler(
NamedPropertyGetterCallback getter,
NamedPropertySetterCallback setter = 0,
@@ -3793,6 +4048,7 @@
NamedPropertyDeleterCallback deleter = 0,
NamedPropertyEnumeratorCallback enumerator = 0,
Handle<Value> data = Handle<Value>());
+ void SetHandler(const NamedPropertyHandlerConfiguration& configuration);
/**
* Sets an indexed property handler on the object template.
@@ -3810,14 +4066,18 @@
* \param data A piece of data that will be passed to the callbacks
* whenever they are invoked.
*/
+ void SetHandler(const IndexedPropertyHandlerConfiguration& configuration);
+ // TODO(dcarney): deprecate
void SetIndexedPropertyHandler(
IndexedPropertyGetterCallback getter,
IndexedPropertySetterCallback setter = 0,
IndexedPropertyQueryCallback query = 0,
IndexedPropertyDeleterCallback deleter = 0,
IndexedPropertyEnumeratorCallback enumerator = 0,
- Handle<Value> data = Handle<Value>());
-
+ Handle<Value> data = Handle<Value>()) {
+ SetHandler(IndexedPropertyHandlerConfiguration(getter, setter, query,
+ deleter, enumerator, data));
+ }
/**
* Sets the callback to be used when calling instances created from
* this template as a function. If no callback is set, instances
@@ -4122,6 +4382,19 @@
static Local<Value> SyntaxError(Handle<String> message);
static Local<Value> TypeError(Handle<String> message);
static Local<Value> Error(Handle<String> message);
+
+ /**
+ * Creates an error message for the given exception.
+ * Will try to reconstruct the original stack trace from the exception value,
+ * or capture the current stack trace if not available.
+ */
+ static Local<Message> CreateMessage(Handle<Value> exception);
+
+ /**
+ * Returns the original stack trace that was captured at the creation time
+ * of a given exception, or an empty handle if not available.
+ */
+ static Local<StackTrace> GetStackTrace(Handle<Value> exception);
};
@@ -4137,18 +4410,19 @@
typedef void (*AddHistogramSampleCallback)(void* histogram, int sample);
// --- Memory Allocation Callback ---
- enum ObjectSpace {
- kObjectSpaceNewSpace = 1 << 0,
- kObjectSpaceOldPointerSpace = 1 << 1,
- kObjectSpaceOldDataSpace = 1 << 2,
- kObjectSpaceCodeSpace = 1 << 3,
- kObjectSpaceMapSpace = 1 << 4,
- kObjectSpaceLoSpace = 1 << 5,
-
- kObjectSpaceAll = kObjectSpaceNewSpace | kObjectSpaceOldPointerSpace |
- kObjectSpaceOldDataSpace | kObjectSpaceCodeSpace | kObjectSpaceMapSpace |
- kObjectSpaceLoSpace
- };
+enum ObjectSpace {
+ kObjectSpaceNewSpace = 1 << 0,
+ kObjectSpaceOldPointerSpace = 1 << 1,
+ kObjectSpaceOldDataSpace = 1 << 2,
+ kObjectSpaceCodeSpace = 1 << 3,
+ kObjectSpaceMapSpace = 1 << 4,
+ kObjectSpaceCellSpace = 1 << 5,
+ kObjectSpacePropertyCellSpace = 1 << 6,
+ kObjectSpaceLoSpace = 1 << 7,
+ kObjectSpaceAll = kObjectSpaceNewSpace | kObjectSpaceOldPointerSpace |
+ kObjectSpaceOldDataSpace | kObjectSpaceCodeSpace |
+ kObjectSpaceMapSpace | kObjectSpaceLoSpace
+};
enum AllocationAction {
kAllocationActionAllocate = 1 << 0,
@@ -4163,6 +4437,37 @@
// --- Leave Script Callback ---
typedef void (*CallCompletedCallback)();
+// --- Promise Reject Callback ---
+enum PromiseRejectEvent {
+ kPromiseRejectWithNoHandler = 0,
+ kPromiseHandlerAddedAfterReject = 1
+};
+
+class PromiseRejectMessage {
+ public:
+ PromiseRejectMessage(Handle<Promise> promise, PromiseRejectEvent event,
+ Handle<Value> value, Handle<StackTrace> stack_trace)
+ : promise_(promise),
+ event_(event),
+ value_(value),
+ stack_trace_(stack_trace) {}
+
+ V8_INLINE Handle<Promise> GetPromise() const { return promise_; }
+ V8_INLINE PromiseRejectEvent GetEvent() const { return event_; }
+ V8_INLINE Handle<Value> GetValue() const { return value_; }
+
+ // DEPRECATED. Use v8::Exception::CreateMessage(GetValue())->GetStackTrace()
+ V8_INLINE Handle<StackTrace> GetStackTrace() const { return stack_trace_; }
+
+ private:
+ Handle<Promise> promise_;
+ PromiseRejectEvent event_;
+ Handle<Value> value_;
+ Handle<StackTrace> stack_trace_;
+};
+
+typedef void (*PromiseRejectCallback)(PromiseRejectMessage message);
+
// --- Microtask Callback ---
typedef void (*MicrotaskCallback)(void* data);
@@ -4334,6 +4639,27 @@
/**
+ * Interface for iterating through all external resources in the heap.
+ */
+class V8_EXPORT ExternalResourceVisitor { // NOLINT
+ public:
+ virtual ~ExternalResourceVisitor() {}
+ virtual void VisitExternalString(Handle<String> string) {}
+};
+
+
+/**
+ * Interface for iterating through all the persistent handles in the heap.
+ */
+class V8_EXPORT PersistentHandleVisitor { // NOLINT
+ public:
+ virtual ~PersistentHandleVisitor() {}
+ virtual void VisitPersistentHandle(Persistent<Value>* value,
+ uint16_t class_id) {}
+};
+
+
+/**
* Isolate represents an isolated instance of the V8 engine. V8 isolates have
* completely separate states. Objects from one isolate must not be used in
* other isolates. The embedder can create multiple isolates and use them in
@@ -4473,6 +4799,7 @@
*/
enum UseCounterFeature {
kUseAsm = 0,
+ kBreakIterator = 1,
kUseCounterFeatureCount // This enum value must be last.
};
@@ -4494,6 +4821,8 @@
/**
* Returns the entered isolate for the current thread or NULL in
* case there is no current isolate.
+ *
+ * This method must not be invoked before V8::Initialize() was invoked.
*/
static Isolate* GetCurrent();
@@ -4548,6 +4877,21 @@
void GetHeapStatistics(HeapStatistics* heap_statistics);
/**
+ * Get a call stack sample from the isolate.
+ * \param state Execution state.
+ * \param frames Caller allocated buffer to store stack frames.
+ * \param frames_limit Maximum number of frames to capture. The buffer must
+ * be large enough to hold the number of frames.
+ * \param sample_info The sample info is filled up by the function
+ * provides number of actual captured stack frames and
+ * the current VM state.
+ * \note GetStackSample should only be called when the JS thread is paused or
+ * interrupted. Otherwise the behavior is undefined.
+ */
+ void GetStackSample(const RegisterState& state, void** frames,
+ size_t frames_limit, SampleInfo* sample_info);
+
+ /**
* Adjusts the amount of registered external memory. Used to give V8 an
* indication of the amount of externally allocated memory that is kept alive
* by JavaScript objects. V8 uses this to decide when to perform global
@@ -4676,12 +5020,47 @@
*/
void RemoveGCEpilogueCallback(GCEpilogueCallback callback);
+
+ /**
+ * Forcefully terminate the current thread of JavaScript execution
+ * in the given isolate.
+ *
+ * This method can be used by any thread even if that thread has not
+ * acquired the V8 lock with a Locker object.
+ */
+ void TerminateExecution();
+
+ /**
+ * Is V8 terminating JavaScript execution.
+ *
+ * Returns true if JavaScript execution is currently terminating
+ * because of a call to TerminateExecution. In that case there are
+ * still JavaScript frames on the stack and the termination
+ * exception is still active.
+ */
+ bool IsExecutionTerminating();
+
+ /**
+ * Resume execution capability in the given isolate, whose execution
+ * was previously forcefully terminated using TerminateExecution().
+ *
+ * When execution is forcefully terminated using TerminateExecution(),
+ * the isolate can not resume execution until all JavaScript frames
+ * have propagated the uncatchable exception which is generated. This
+ * method allows the program embedding the engine to handle the
+ * termination event and resume execution capability, even if
+ * JavaScript frames remain on the stack.
+ *
+ * This method can be used by any thread even if that thread has not
+ * acquired the V8 lock with a Locker object.
+ */
+ void CancelTerminateExecution();
+
/**
* 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.
+ * There may be a number of interrupt requests in flight.
* Can be called from another thread without acquiring a |Locker|.
* Registered |callback| must not reenter interrupted Isolate.
*/
@@ -4691,7 +5070,8 @@
* Clear interrupt request created by |RequestInterrupt|.
* Can be called from another thread without acquiring a |Locker|.
*/
- void ClearInterrupt();
+ V8_DEPRECATED("There's no way to clear interrupts in flight.",
+ void ClearInterrupt());
/**
* Request garbage collection in this Isolate. It is only valid to call this
@@ -4723,6 +5103,13 @@
*/
void RemoveCallCompletedCallback(CallCompletedCallback callback);
+
+ /**
+ * Set callback to notify about promise reject with no handler, or
+ * revocation of such a previous notification once the handler is added.
+ */
+ void SetPromiseRejectCallback(PromiseRejectCallback callback);
+
/**
* Experimental: Runs the Microtask Work Queue until empty
* Any exceptions thrown by microtask callbacks are swallowed.
@@ -4773,17 +5160,23 @@
/**
* Optional notification that the embedder is idle.
- * V8 uses the notification to reduce memory footprint.
+ * V8 uses the notification to perform garbage collection.
* This call can be used repeatedly if the embedder remains idle.
* Returns true if the embedder should stop calling IdleNotification
* until real work has been done. This indicates that V8 has done
* as much cleanup as it will be able to do.
*
- * The idle_time_in_ms argument specifies the time V8 has to do reduce
- * the memory footprint. There is no guarantee that the actual work will be
+ * The idle_time_in_ms argument specifies the time V8 has to perform
+ * garbage collection. There is no guarantee that the actual work will be
* done within the time limit.
+ * The deadline_in_seconds argument specifies the deadline V8 has to finish
+ * garbage collection work. deadline_in_seconds is compared with
+ * MonotonicallyIncreasingTime() and should be based on the same timebase as
+ * that function. There is no guarantee that the actual work will be done
+ * within the time limit.
*/
bool IdleNotification(int idle_time_in_ms);
+ bool IdleNotificationDeadline(double deadline_in_seconds);
/**
* Optional notification that the system is running low on memory.
@@ -4796,8 +5189,11 @@
* these notifications to guide the GC heuristic. Returns the number
* of context disposals - including this one - since the last time
* V8 had a chance to clean up.
+ *
+ * The optional parameter |dependant_context| specifies whether the disposed
+ * context was depending on state from other contexts or not.
*/
- int ContextDisposedNotification();
+ int ContextDisposedNotification(bool dependant_context = true);
/**
* Allows the host application to provide the address of a function that is
@@ -4835,6 +5231,99 @@
*/
void SetStackLimit(uintptr_t stack_limit);
+ /**
+ * Returns a memory range that can potentially contain jitted code.
+ *
+ * On Win64, embedders are advised to install function table callbacks for
+ * these ranges, as default SEH won't be able to unwind through jitted code.
+ *
+ * The first page of the code range is reserved for the embedder and is
+ * committed, writable, and executable.
+ *
+ * Might be empty on other platforms.
+ *
+ * https://code.google.com/p/v8/issues/detail?id=3598
+ */
+ void GetCodeRange(void** start, size_t* length_in_bytes);
+
+ /** Set the callback to invoke in case of fatal errors. */
+ void SetFatalErrorHandler(FatalErrorCallback that);
+
+ /**
+ * Set the callback to invoke to check if code generation from
+ * strings should be allowed.
+ */
+ void SetAllowCodeGenerationFromStringsCallback(
+ AllowCodeGenerationFromStringsCallback callback);
+
+ /**
+ * Check if V8 is dead and therefore unusable. This is the case after
+ * fatal errors such as out-of-memory situations.
+ */
+ bool IsDead();
+
+ /**
+ * Adds a message listener.
+ *
+ * The same message listener can be added more than once and in that
+ * case it will be called more than once for each message.
+ *
+ * If data is specified, it will be passed to the callback when it is called.
+ * Otherwise, the exception object will be passed to the callback instead.
+ */
+ bool AddMessageListener(MessageCallback that,
+ Handle<Value> data = Handle<Value>());
+
+ /**
+ * Remove all message listeners from the specified callback function.
+ */
+ void RemoveMessageListeners(MessageCallback that);
+
+ /** Callback function for reporting failed access checks.*/
+ void SetFailedAccessCheckCallbackFunction(FailedAccessCheckCallback);
+
+ /**
+ * Tells V8 to capture current stack trace when uncaught exception occurs
+ * and report it to the message listeners. The option is off by default.
+ */
+ void SetCaptureStackTraceForUncaughtExceptions(
+ bool capture, int frame_limit = 10,
+ StackTrace::StackTraceOptions options = StackTrace::kOverview);
+
+ /**
+ * Enables the host application to provide a mechanism to be notified
+ * and perform custom logging when V8 Allocates Executable Memory.
+ */
+ void AddMemoryAllocationCallback(MemoryAllocationCallback callback,
+ ObjectSpace space, AllocationAction action);
+
+ /**
+ * Removes callback that was installed by AddMemoryAllocationCallback.
+ */
+ void RemoveMemoryAllocationCallback(MemoryAllocationCallback callback);
+
+ /**
+ * Iterates through all external resources referenced from current isolate
+ * heap. GC is not invoked prior to iterating, therefore there is no
+ * guarantee that visited objects are still alive.
+ */
+ void VisitExternalResources(ExternalResourceVisitor* visitor);
+
+ /**
+ * Iterates through all the persistent handles in the current isolate's heap
+ * that have class_ids.
+ */
+ void VisitHandlesWithClassIds(PersistentHandleVisitor* visitor);
+
+ /**
+ * Iterates through all the persistent handles in the current isolate's heap
+ * that have class_ids and are candidates to be marked as partially dependent
+ * handles. This will visit handles to young objects created since the last
+ * garbage collection but is free to visit an arbitrary superset of these
+ * objects.
+ */
+ void VisitHandlesForPartialDependence(PersistentHandleVisitor* visitor);
+
private:
template<class K, class V, class Traits> friend class PersistentValueMap;
@@ -4853,43 +5342,12 @@
class V8_EXPORT StartupData {
public:
- enum CompressionAlgorithm {
- kUncompressed,
- kBZip2
- };
-
const char* data;
- int compressed_size;
int raw_size;
};
/**
- * A helper class for driving V8 startup data decompression. It is based on
- * "CompressedStartupData" API functions from the V8 class. It isn't mandatory
- * for an embedder to use this class, instead, API functions can be used
- * directly.
- *
- * For an example of the class usage, see the "shell.cc" sample application.
- */
-class V8_EXPORT StartupDataDecompressor { // NOLINT
- public:
- StartupDataDecompressor();
- virtual ~StartupDataDecompressor();
- int Decompress();
-
- protected:
- virtual int DecompressData(char* raw_data,
- int* raw_data_size,
- const char* compressed_data,
- int compressed_data_size) = 0;
-
- private:
- char** raw_data;
-};
-
-
-/**
* EntropySource is used as a callback function when v8 needs a source
* of entropy.
*/
@@ -4914,39 +5372,20 @@
/**
- * Interface for iterating through all external resources in the heap.
- */
-class V8_EXPORT ExternalResourceVisitor { // NOLINT
- public:
- virtual ~ExternalResourceVisitor() {}
- virtual void VisitExternalString(Handle<String> string) {}
-};
-
-
-/**
- * Interface for iterating through all the persistent handles in the heap.
- */
-class V8_EXPORT PersistentHandleVisitor { // NOLINT
- public:
- virtual ~PersistentHandleVisitor() {}
- virtual void VisitPersistentHandle(Persistent<Value>* value,
- uint16_t class_id) {}
-};
-
-
-/**
* Container class for static utility functions.
*/
class V8_EXPORT V8 {
public:
/** Set the callback to invoke in case of fatal errors. */
- static void SetFatalErrorHandler(FatalErrorCallback that);
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static void SetFatalErrorHandler(FatalErrorCallback that);
/**
* Set the callback to invoke to check if code generation from
* strings should be allowed.
*/
- static void SetAllowCodeGenerationFromStringsCallback(
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static void SetAllowCodeGenerationFromStringsCallback(
AllowCodeGenerationFromStringsCallback that);
/**
@@ -4958,34 +5397,11 @@
static void SetArrayBufferAllocator(ArrayBuffer::Allocator* allocator);
/**
- * Check if V8 is dead and therefore unusable. This is the case after
- * fatal errors such as out-of-memory situations.
- */
- static bool IsDead();
-
- /**
- * The following 4 functions are to be used when V8 is built with
- * the 'compress_startup_data' flag enabled. In this case, the
- * embedder must decompress startup data prior to initializing V8.
- *
- * This is how interaction with V8 should look like:
- * int compressed_data_count = v8::V8::GetCompressedStartupDataCount();
- * v8::StartupData* compressed_data =
- * new v8::StartupData[compressed_data_count];
- * v8::V8::GetCompressedStartupData(compressed_data);
- * ... decompress data (compressed_data can be updated in-place) ...
- * v8::V8::SetDecompressedStartupData(compressed_data);
- * ... now V8 can be initialized
- * ... make sure the decompressed data stays valid until V8 shutdown
- *
- * A helper class StartupDataDecompressor is provided. It implements
- * the protocol of the interaction described above, and can be used in
- * most cases instead of calling these API functions directly.
- */
- static StartupData::CompressionAlgorithm GetCompressedStartupDataAlgorithm();
- static int GetCompressedStartupDataCount();
- static void GetCompressedStartupData(StartupData* compressed_data);
- static void SetDecompressedStartupData(StartupData* decompressed_data);
+ * Check if V8 is dead and therefore unusable. This is the case after
+ * fatal errors such as out-of-memory situations.
+ */
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static bool IsDead();
/**
* Hand startup data to V8, in case the embedder has chosen to build
@@ -5006,6 +5422,13 @@
static void SetSnapshotDataBlob(StartupData* startup_blob);
/**
+ * Create a new isolate and context for the purpose of capturing a snapshot
+ * Returns { NULL, 0 } on failure.
+ * The caller owns the data array in the return value.
+ */
+ static StartupData CreateSnapshotDataBlob();
+
+ /**
* Adds a message listener.
*
* The same message listener can be added more than once and in that
@@ -5014,21 +5437,23 @@
* If data is specified, it will be passed to the callback when it is called.
* Otherwise, the exception object will be passed to the callback instead.
*/
- static bool AddMessageListener(MessageCallback that,
- Handle<Value> data = Handle<Value>());
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static bool AddMessageListener(
+ MessageCallback that, Handle<Value> data = Handle<Value>());
/**
* Remove all message listeners from the specified callback function.
*/
- static void RemoveMessageListeners(MessageCallback that);
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static void RemoveMessageListeners(MessageCallback that);
/**
* Tells V8 to capture current stack trace when uncaught exception occurs
* and report it to the message listeners. The option is off by default.
*/
- static void SetCaptureStackTraceForUncaughtExceptions(
- bool capture,
- int frame_limit = 10,
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static void SetCaptureStackTraceForUncaughtExceptions(
+ bool capture, int frame_limit = 10,
StackTrace::StackTraceOptions options = StackTrace::kOverview);
/**
@@ -5047,7 +5472,9 @@
static const char* GetVersion();
/** Callback function for reporting failed access checks.*/
- static void SetFailedAccessCheckCallbackFunction(FailedAccessCheckCallback);
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static void SetFailedAccessCheckCallbackFunction(
+ FailedAccessCheckCallback);
/**
* Enables the host application to receive a notification before a
@@ -5059,6 +5486,7 @@
* register the same callback function two times with different
* GCType filters.
*/
+ // TODO(dcarney): deprecate this.
static void AddGCPrologueCallback(
GCPrologueCallback callback, GCType gc_type_filter = kGCTypeAll);
@@ -5066,7 +5494,8 @@
* This function removes callback which was installed by
* AddGCPrologueCallback function.
*/
- static void RemoveGCPrologueCallback(GCPrologueCallback callback);
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static void RemoveGCPrologueCallback(GCPrologueCallback callback);
/**
* Enables the host application to receive a notification after a
@@ -5078,6 +5507,7 @@
* register the same callback function two times with different
* GCType filters.
*/
+ // TODO(dcarney): deprecate this.
static void AddGCEpilogueCallback(
GCEpilogueCallback callback, GCType gc_type_filter = kGCTypeAll);
@@ -5085,20 +5515,24 @@
* This function removes callback which was installed by
* AddGCEpilogueCallback function.
*/
- static void RemoveGCEpilogueCallback(GCEpilogueCallback callback);
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static void RemoveGCEpilogueCallback(GCEpilogueCallback callback);
/**
* Enables the host application to provide a mechanism to be notified
* and perform custom logging when V8 Allocates Executable Memory.
*/
- static void AddMemoryAllocationCallback(MemoryAllocationCallback callback,
- ObjectSpace space,
- AllocationAction action);
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static void AddMemoryAllocationCallback(
+ MemoryAllocationCallback callback, ObjectSpace space,
+ AllocationAction action);
/**
* Removes callback that was installed by AddMemoryAllocationCallback.
*/
- static void RemoveMemoryAllocationCallback(MemoryAllocationCallback callback);
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static void RemoveMemoryAllocationCallback(
+ MemoryAllocationCallback callback);
/**
* Initializes V8. This function needs to be called before the first Isolate
@@ -5128,7 +5562,8 @@
*
* \param isolate The isolate in which to terminate the current JS execution.
*/
- static void TerminateExecution(Isolate* isolate);
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static void TerminateExecution(Isolate* isolate);
/**
* Is V8 terminating JavaScript execution.
@@ -5140,7 +5575,8 @@
*
* \param isolate The isolate in which to check.
*/
- static bool IsExecutionTerminating(Isolate* isolate = NULL);
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static bool IsExecutionTerminating(Isolate* isolate = NULL);
/**
* Resume execution capability in the given isolate, whose execution
@@ -5158,7 +5594,8 @@
*
* \param isolate The isolate in which to resume execution capability.
*/
- static void CancelTerminateExecution(Isolate* isolate);
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static void CancelTerminateExecution(Isolate* isolate);
/**
* Releases any resources used by v8 and stops any utility threads
@@ -5176,13 +5613,25 @@
* heap. GC is not invoked prior to iterating, therefore there is no
* guarantee that visited objects are still alive.
*/
- static void VisitExternalResources(ExternalResourceVisitor* visitor);
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static void VisitExternalResources(
+ ExternalResourceVisitor* visitor);
/**
* Iterates through all the persistent handles in the current isolate's heap
* that have class_ids.
*/
- static void VisitHandlesWithClassIds(PersistentHandleVisitor* visitor);
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static void VisitHandlesWithClassIds(
+ PersistentHandleVisitor* visitor);
+
+ /**
+ * Iterates through all the persistent handles in isolate's heap that have
+ * class_ids.
+ */
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static void VisitHandlesWithClassIds(
+ Isolate* isolate, PersistentHandleVisitor* visitor);
/**
* Iterates through all the persistent handles in the current isolate's heap
@@ -5191,7 +5640,8 @@
* garbage collection but is free to visit an arbitrary superset of these
* objects.
*/
- static void VisitHandlesForPartialDependence(
+ // TODO(dcarney): deprecate this.
+ V8_INLINE static void VisitHandlesForPartialDependence(
Isolate* isolate, PersistentHandleVisitor* visitor);
/**
@@ -5215,17 +5665,30 @@
*/
static void ShutdownPlatform();
+ /**
+ * Returns the current v8::Platform in use.
+ */
+ static v8::Platform* GetCurrentPlatform();
+
private:
V8();
+ enum WeakHandleType { PhantomHandle, NonphantomHandle };
+
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 WeakCallbackData<Value, void>::Callback WeakCallback;
- static void MakeWeak(internal::Object** global_handle,
- void* data,
+ static void MakeWeak(internal::Object** global_handle, void* data,
WeakCallback weak_callback);
+ static void MakePhantom(internal::Object** global_handle, void* data,
+ PhantomCallbackData<void>::Callback weak_callback);
+ static void MakePhantom(
+ internal::Object** global_handle,
+ InternalFieldsCallbackData<void, void>::Callback weak_callback,
+ int internal_field_index1,
+ int internal_field_index2 = Object::kNoInternalFieldIndex);
static void* ClearWeak(internal::Object** global_handle);
static void Eternalize(Isolate* isolate,
Value* handle,
@@ -5251,9 +5714,17 @@
* all TryCatch blocks should be stack allocated because the memory
* location itself is compared against JavaScript try/catch blocks.
*/
+ // TODO(dcarney): deprecate.
TryCatch();
/**
+ * Creates a new try/catch block and registers it with v8. Note that
+ * all TryCatch blocks should be stack allocated because the memory
+ * location itself is compared against JavaScript try/catch blocks.
+ */
+ TryCatch(Isolate* isolate);
+
+ /**
* Unregisters and deletes this try/catch block.
*/
~TryCatch();
@@ -5692,8 +6163,6 @@
bool top_level_;
internal::Isolate* isolate_;
- static bool active_;
-
// Disallow copying and assigning.
Locker(const Locker&);
void operator=(const Locker&);
@@ -5802,7 +6271,7 @@
static const int kJSObjectHeaderSize = 3 * kApiPointerSize;
static const int kFixedArrayHeaderSize = 2 * kApiPointerSize;
static const int kContextHeaderSize = 2 * kApiPointerSize;
- static const int kContextEmbedderDataIndex = 95;
+ static const int kContextEmbedderDataIndex = 76;
static const int kFullStringRepresentationMask = 0x07;
static const int kStringEncodingMask = 0x4;
static const int kExternalTwoByteRepresentationTag = 0x02;
@@ -5820,7 +6289,7 @@
static const int kNullValueRootIndex = 7;
static const int kTrueValueRootIndex = 8;
static const int kFalseValueRootIndex = 9;
- static const int kEmptyStringRootIndex = 164;
+ static const int kEmptyStringRootIndex = 154;
// The external allocation limit should be below 256 MB on all architectures
// to avoid that resource-constrained embedders run low on memory.
@@ -5828,14 +6297,14 @@
static const int kNodeClassIdOffset = 1 * kApiPointerSize;
static const int kNodeFlagsOffset = 1 * kApiPointerSize + 3;
- static const int kNodeStateMask = 0xf;
+ static const int kNodeStateMask = 0x7;
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;
+ static const int kNodeIsIndependentShift = 3;
+ static const int kNodeIsPartiallyDependentShift = 4;
- static const int kJSObjectType = 0xbc;
+ static const int kJSObjectType = 0xbd;
static const int kFirstNonstringType = 0x80;
static const int kOddballType = 0x83;
static const int kForeignType = 0x88;
@@ -6090,8 +6559,7 @@
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,
+ V8::MakeWeak(reinterpret_cast<internal::Object**>(this->val_), parameter,
reinterpret_cast<Callback>(callback));
}
@@ -6106,7 +6574,29 @@
template <class T>
-template<typename P>
+template <typename P>
+void PersistentBase<T>::SetPhantom(
+ P* parameter, typename PhantomCallbackData<P>::Callback callback) {
+ typedef typename PhantomCallbackData<void>::Callback Callback;
+ V8::MakePhantom(reinterpret_cast<internal::Object**>(this->val_), parameter,
+ reinterpret_cast<Callback>(callback));
+}
+
+
+template <class T>
+template <typename U, typename V>
+void PersistentBase<T>::SetPhantom(
+ void (*callback)(const InternalFieldsCallbackData<U, V>&),
+ int internal_field_index1, int internal_field_index2) {
+ typedef typename InternalFieldsCallbackData<void, void>::Callback Callback;
+ V8::MakePhantom(reinterpret_cast<internal::Object**>(this->val_),
+ reinterpret_cast<Callback>(callback), internal_field_index1,
+ internal_field_index2);
+}
+
+
+template <class T>
+template <typename P>
P* PersistentBase<T>::ClearWeak() {
return reinterpret_cast<P*>(
V8::ClearWeak(reinterpret_cast<internal::Object**>(this->val_)));
@@ -6133,15 +6623,6 @@
}
-template <class T, class M>
-T* Persistent<T, M>::ClearAndLeak() {
- T* old;
- old = this->val_;
- this->val_ = NULL;
- return old;
-}
-
-
template <class T>
void PersistentBase<T>::SetWrapperClassId(uint16_t class_id) {
typedef internal::Internals I;
@@ -6547,6 +7028,44 @@
}
+Local<Boolean> Value::ToBoolean() const {
+ return ToBoolean(Isolate::GetCurrent());
+}
+
+
+Local<Number> Value::ToNumber() const {
+ return ToNumber(Isolate::GetCurrent());
+}
+
+
+Local<String> Value::ToString() const {
+ return ToString(Isolate::GetCurrent());
+}
+
+
+Local<String> Value::ToDetailString() const {
+ return ToDetailString(Isolate::GetCurrent());
+}
+
+
+Local<Object> Value::ToObject() const {
+ return ToObject(Isolate::GetCurrent());
+}
+
+
+Local<Integer> Value::ToInteger() const {
+ return ToInteger(Isolate::GetCurrent());
+}
+
+
+Local<Uint32> Value::ToUint32() const {
+ return ToUint32(Isolate::GetCurrent());
+}
+
+
+Local<Int32> Value::ToInt32() const { return ToInt32(Isolate::GetCurrent()); }
+
+
Name* Name::Cast(v8::Value* value) {
#ifdef V8_ENABLE_CHECKS
CheckCast(value);
@@ -6937,6 +7456,119 @@
}
+void V8::SetAllowCodeGenerationFromStringsCallback(
+ AllowCodeGenerationFromStringsCallback callback) {
+ Isolate* isolate = Isolate::GetCurrent();
+ isolate->SetAllowCodeGenerationFromStringsCallback(callback);
+}
+
+
+bool V8::IsDead() {
+ Isolate* isolate = Isolate::GetCurrent();
+ return isolate->IsDead();
+}
+
+
+bool V8::AddMessageListener(MessageCallback that, Handle<Value> data) {
+ Isolate* isolate = Isolate::GetCurrent();
+ return isolate->AddMessageListener(that, data);
+}
+
+
+void V8::RemoveMessageListeners(MessageCallback that) {
+ Isolate* isolate = Isolate::GetCurrent();
+ isolate->RemoveMessageListeners(that);
+}
+
+
+void V8::SetFailedAccessCheckCallbackFunction(
+ FailedAccessCheckCallback callback) {
+ Isolate* isolate = Isolate::GetCurrent();
+ isolate->SetFailedAccessCheckCallbackFunction(callback);
+}
+
+
+void V8::SetCaptureStackTraceForUncaughtExceptions(
+ bool capture, int frame_limit, StackTrace::StackTraceOptions options) {
+ Isolate* isolate = Isolate::GetCurrent();
+ isolate->SetCaptureStackTraceForUncaughtExceptions(capture, frame_limit,
+ options);
+}
+
+
+void V8::SetFatalErrorHandler(FatalErrorCallback callback) {
+ Isolate* isolate = Isolate::GetCurrent();
+ isolate->SetFatalErrorHandler(callback);
+}
+
+
+void V8::RemoveGCPrologueCallback(GCPrologueCallback callback) {
+ Isolate* isolate = Isolate::GetCurrent();
+ isolate->RemoveGCPrologueCallback(
+ reinterpret_cast<v8::Isolate::GCPrologueCallback>(callback));
+}
+
+
+void V8::RemoveGCEpilogueCallback(GCEpilogueCallback callback) {
+ Isolate* isolate = Isolate::GetCurrent();
+ isolate->RemoveGCEpilogueCallback(
+ reinterpret_cast<v8::Isolate::GCEpilogueCallback>(callback));
+}
+
+
+void V8::AddMemoryAllocationCallback(MemoryAllocationCallback callback,
+ ObjectSpace space,
+ AllocationAction action) {
+ Isolate* isolate = Isolate::GetCurrent();
+ isolate->AddMemoryAllocationCallback(callback, space, action);
+}
+
+
+void V8::RemoveMemoryAllocationCallback(MemoryAllocationCallback callback) {
+ Isolate* isolate = Isolate::GetCurrent();
+ isolate->RemoveMemoryAllocationCallback(callback);
+}
+
+
+void V8::TerminateExecution(Isolate* isolate) { isolate->TerminateExecution(); }
+
+
+bool V8::IsExecutionTerminating(Isolate* isolate) {
+ if (isolate == NULL) {
+ isolate = Isolate::GetCurrent();
+ }
+ return isolate->IsExecutionTerminating();
+}
+
+
+void V8::CancelTerminateExecution(Isolate* isolate) {
+ isolate->CancelTerminateExecution();
+}
+
+
+void V8::VisitExternalResources(ExternalResourceVisitor* visitor) {
+ Isolate* isolate = Isolate::GetCurrent();
+ isolate->VisitExternalResources(visitor);
+}
+
+
+void V8::VisitHandlesWithClassIds(PersistentHandleVisitor* visitor) {
+ Isolate* isolate = Isolate::GetCurrent();
+ isolate->VisitHandlesWithClassIds(visitor);
+}
+
+
+void V8::VisitHandlesWithClassIds(Isolate* isolate,
+ PersistentHandleVisitor* visitor) {
+ isolate->VisitHandlesWithClassIds(visitor);
+}
+
+
+void V8::VisitHandlesForPartialDependence(Isolate* isolate,
+ PersistentHandleVisitor* visitor) {
+ isolate->VisitHandlesForPartialDependence(visitor);
+}
+
/**
* \example shell.cc
* A simple shell that takes a list of expressions on the