template<class T> class PersistentBase;
template<class T,
class M = NonCopyablePersistentTraits<T> > class Persistent;
-template <class T>
-class Global;
+template<class T> class UniquePersistent;
template<class K, class V, class T> class PersistentValueMap;
template <class K, class V, class T>
class PersistentValueMapBase;
template<class F> friend class Handle;
template<class F> friend class Local;
template<class F1, class F2> friend class Persistent;
- template <class F>
- friend class Global;
+ template<class F> friend class UniquePersistent;
template<class F> friend class PersistentBase;
template<class F> friend class ReturnValue;
template <class F1, class F2, class F3>
*
* Note: Persistent class hierarchy is subject to future changes.
*/
-template <class T>
-class Global : public PersistentBase<T> {
+template<class T>
+class UniquePersistent : public PersistentBase<T> {
public:
/**
- * A Global with no storage cell.
+ * A UniquePersistent with no storage cell.
*/
- V8_INLINE Global() : PersistentBase<T>(nullptr) {}
+ V8_INLINE UniquePersistent() : PersistentBase<T>(nullptr) {}
/**
- * Construct a Global from a Handle.
+ * Construct a UniquePersistent from a Handle.
* When the Handle is non-empty, a new storage cell is created
* pointing to the same object, and no flags are set.
*/
template <class S>
- V8_INLINE Global(Isolate* isolate, Handle<S> that)
+ V8_INLINE UniquePersistent(Isolate* isolate, Handle<S> that)
: PersistentBase<T>(PersistentBase<T>::New(isolate, *that)) {
TYPE_CHECK(T, S);
}
/**
- * Construct a Global from a PersistentBase.
+ * Construct a UniquePersistent from a PersistentBase.
* When the Persistent is non-empty, a new storage cell is created
* pointing to the same object, and no flags are set.
*/
template <class S>
- V8_INLINE Global(Isolate* isolate, const PersistentBase<S>& that)
- : PersistentBase<T>(PersistentBase<T>::New(isolate, that.val_)) {
+ V8_INLINE UniquePersistent(Isolate* isolate, const PersistentBase<S>& that)
+ : PersistentBase<T>(PersistentBase<T>::New(isolate, that.val_)) {
TYPE_CHECK(T, S);
}
/**
* Move constructor.
*/
- V8_INLINE Global(Global&& other) : PersistentBase<T>(other.val_) {
+ V8_INLINE UniquePersistent(UniquePersistent&& other)
+ : PersistentBase<T>(other.val_) {
other.val_ = nullptr;
}
- V8_INLINE ~Global() { this->Reset(); }
+ V8_INLINE ~UniquePersistent() { this->Reset(); }
/**
* Move via assignment.
*/
template <class S>
- V8_INLINE Global& operator=(Global<S>&& rhs) {
+ V8_INLINE UniquePersistent& operator=(UniquePersistent<S>&& rhs) {
TYPE_CHECK(T, S);
if (this != &rhs) {
this->Reset();
/**
* Pass allows returning uniques from functions, etc.
*/
- Global Pass() { return static_cast<Global&&>(*this); }
+ UniquePersistent Pass() { return static_cast<UniquePersistent&&>(*this); }
private:
- Global(Global&) = delete;
- void operator=(Global&) = delete;
+ UniquePersistent(UniquePersistent&) = delete;
+ void operator=(UniquePersistent&) = delete;
};
-// UniquePersistent is an alias for Global for historical reason.
-template <class T>
-using UniquePersistent = Global<T>;
-
-
/**
* A stack-allocated class that governs a number of local handles.
* After a handle scope has been created, all local handles will be
void* huge = reinterpret_cast<void*>(~static_cast<uintptr_t>(1));
CheckAlignedPointerInInternalField(obj, huge);
- v8::Global<v8::Object> persistent(isolate, obj);
+ v8::UniquePersistent<v8::Object> persistent(isolate, obj);
CHECK_EQ(1, Object::InternalFieldCount(persistent));
CHECK_EQ(huge, Object::GetAlignedPointerFromInternalField(persistent, 0));
}
template <class T>
-static v8::Global<T> PassUnique(v8::Global<T> unique) {
+static v8::UniquePersistent<T> PassUnique(v8::UniquePersistent<T> unique) {
return unique.Pass();
}
template <class T>
-static v8::Global<T> ReturnUnique(v8::Isolate* isolate,
- const v8::Persistent<T>& global) {
- v8::Global<String> unique(isolate, global);
+static v8::UniquePersistent<T> ReturnUnique(v8::Isolate* isolate,
+ const v8::Persistent<T>& global) {
+ v8::UniquePersistent<String> unique(isolate, global);
return unique.Pass();
}
-THREADED_TEST(Global) {
+THREADED_TEST(UniquePersistent) {
v8::Isolate* isolate = CcTest::isolate();
v8::Persistent<String> global;
{
reinterpret_cast<v8::internal::Isolate*>(isolate)->global_handles();
int initial_handle_count = global_handles->global_handles_count();
{
- v8::Global<String> unique(isolate, global);
+ v8::UniquePersistent<String> unique(isolate, global);
CHECK_EQ(initial_handle_count + 1, global_handles->global_handles_count());
// Test assignment via Pass
{
- v8::Global<String> copy = unique.Pass();
+ v8::UniquePersistent<String> copy = unique.Pass();
CHECK(unique.IsEmpty());
CHECK(copy == global);
CHECK_EQ(initial_handle_count + 1,
}
// Test ctor via Pass
{
- v8::Global<String> copy(unique.Pass());
+ v8::UniquePersistent<String> copy(unique.Pass());
CHECK(unique.IsEmpty());
CHECK(copy == global);
CHECK_EQ(initial_handle_count + 1,
}
// Test pass through function call
{
- v8::Global<String> copy = PassUnique(unique.Pass());
+ v8::UniquePersistent<String> copy = PassUnique(unique.Pass());
CHECK(unique.IsEmpty());
CHECK(copy == global);
CHECK_EQ(initial_handle_count + 1,
}
// Test pass from function call
{
- v8::Global<String> unique = ReturnUnique(isolate, global);
+ v8::UniquePersistent<String> unique = ReturnUnique(isolate, global);
CHECK(unique == global);
CHECK_EQ(initial_handle_count + 1, global_handles->global_handles_count());
}
return data.GetParameter()->key;
}
static void DisposeCallbackData(WeakCallbackDataType* data) { delete data; }
- static void Dispose(v8::Isolate* isolate, v8::Global<V> value, K key) {}
+ static void Dispose(v8::Isolate* isolate, v8::UniquePersistent<V> value,
+ K key) {}
};
typename Map::PersistentValueReference ref = map.GetReference(7);
CHECK(expected->Equals(ref.NewLocal(isolate)));
}
- v8::Global<v8::Object> removed = map.Remove(7);
+ v8::UniquePersistent<v8::Object> removed = map.Remove(7);
CHECK_EQ(0, static_cast<int>(map.Size()));
CHECK(expected == removed);
removed = map.Remove(7);
{
typename Map::PersistentValueReference ref;
Local<v8::Object> expected2 = v8::Object::New(isolate);
- removed = map.Set(8, v8::Global<v8::Object>(isolate, expected2), &ref);
+ removed = map.Set(8, v8::UniquePersistent<v8::Object>(isolate, expected2),
+ &ref);
CHECK_EQ(1, static_cast<int>(map.Size()));
CHECK(expected == removed);
CHECK(expected2->Equals(ref.NewLocal(isolate)));
Local<v8::Object> obj1 = v8::Object::New(isolate);
Local<v8::Object> obj2 = v8::Object::New(isolate);
- v8::Global<v8::Object> obj3(isolate, v8::Object::New(isolate));
+ v8::UniquePersistent<v8::Object> obj3(isolate, v8::Object::New(isolate));
CHECK(vector.IsEmpty());
CHECK_EQ(0, static_cast<int>(vector.Size()));