AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

rename UniquePersistent to Global

Browse Source 
BUG=

Review URL: https://codereview.chromium.org/980173003

Cr-Commit-Position: refs/heads/master@{#27011}
This commit is contained in:
dcarney 2015-03-05 03:40:35 -08:00 committed by Commit bot
parent d271599f08
commit 3f5ae16c62
2 changed files with 39 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
include/v8.h
View File

@ -115,7 +115,8 @@ template<class T> class NonCopyablePersistentTraits;
template<class T> class PersistentBase; template<class T> class PersistentBase;
template<class T, template<class T,
class M = NonCopyablePersistentTraits<T> > class Persistent; class M = NonCopyablePersistentTraits<T> > class Persistent;
template<class T> class UniquePersistent; template <class T>
class Global;
template<class K, class V, class T> class PersistentValueMap; template<class K, class V, class T> class PersistentValueMap;
template <class K, class V, class T> template <class K, class V, class T>
class PersistentValueMapBase; class PersistentValueMapBase;
@ -656,7 +657,8 @@ template <class T> class PersistentBase {
template<class F> friend class Handle; template<class F> friend class Handle;
template<class F> friend class Local; template<class F> friend class Local;
template<class F1, class F2> friend class Persistent; template<class F1, class F2> friend class Persistent;
template<class F> friend class UniquePersistent; template <class F>
friend class Global;
template<class F> friend class PersistentBase; template<class F> friend class PersistentBase;
template<class F> friend class ReturnValue; template<class F> friend class ReturnValue;
template <class F1, class F2, class F3> template <class F1, class F2, class F3>
@ -812,46 +814,45 @@ template <class T, class M> class Persistent : public PersistentBase<T> {
* *
* Note: Persistent class hierarchy is subject to future changes. * Note: Persistent class hierarchy is subject to future changes.
*/ */
template<class T> template <class T>
class UniquePersistent : public PersistentBase<T> { class Global : public PersistentBase<T> {
public: public:
/** /**
* A UniquePersistent with no storage cell. * A Global with no storage cell.
*/ */
V8_INLINE UniquePersistent() : PersistentBase<T>(nullptr) {} V8_INLINE Global() : PersistentBase<T>(nullptr) {}
/** /**
* Construct a UniquePersistent from a Handle. * Construct a Global from a Handle.
* When the Handle is non-empty, a new storage cell is created * When the Handle is non-empty, a new storage cell is created
* pointing to the same object, and no flags are set. * pointing to the same object, and no flags are set.
*/ */
template <class S> template <class S>
V8_INLINE UniquePersistent(Isolate* isolate, Handle<S> that) V8_INLINE Global(Isolate* isolate, Handle<S> that)
: PersistentBase<T>(PersistentBase<T>::New(isolate, *that)) { : PersistentBase<T>(PersistentBase<T>::New(isolate, *that)) {
TYPE_CHECK(T, S); TYPE_CHECK(T, S);
} }
/** /**
* Construct a UniquePersistent from a PersistentBase. * Construct a Global from a PersistentBase.
* When the Persistent is non-empty, a new storage cell is created * When the Persistent is non-empty, a new storage cell is created
* pointing to the same object, and no flags are set. * pointing to the same object, and no flags are set.
*/ */
template <class S> template <class S>
V8_INLINE UniquePersistent(Isolate* isolate, const PersistentBase<S>& that) V8_INLINE Global(Isolate* isolate, const PersistentBase<S>& that)
: PersistentBase<T>(PersistentBase<T>::New(isolate, that.val_)) { : PersistentBase<T>(PersistentBase<T>::New(isolate, that.val_)) {
TYPE_CHECK(T, S); TYPE_CHECK(T, S);
} }
/** /**
* Move constructor. * Move constructor.
*/ */
V8_INLINE UniquePersistent(UniquePersistent&& other) V8_INLINE Global(Global&& other) : PersistentBase<T>(other.val_) {
: PersistentBase<T>(other.val_) {
other.val_ = nullptr; other.val_ = nullptr;
} }
V8_INLINE ~UniquePersistent() { this->Reset(); } V8_INLINE ~Global() { this->Reset(); }
/** /**
* Move via assignment. * Move via assignment.
*/ */
template <class S> template <class S>
V8_INLINE UniquePersistent& operator=(UniquePersistent<S>&& rhs) { V8_INLINE Global& operator=(Global<S>&& rhs) {
TYPE_CHECK(T, S); TYPE_CHECK(T, S);
if (this != &rhs) { if (this != &rhs) {
this->Reset(); this->Reset();
@ -863,14 +864,19 @@ class UniquePersistent : public PersistentBase<T> {
/** /**
* Pass allows returning uniques from functions, etc. * Pass allows returning uniques from functions, etc.
*/ */
UniquePersistent Pass() { return static_cast<UniquePersistent&&>(*this); } Global Pass() { return static_cast<Global&&>(*this); }
private: private:
UniquePersistent(UniquePersistent&) = delete; Global(Global&) = delete;
void operator=(UniquePersistent&) = delete; void operator=(Global&) = 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. * A stack-allocated class that governs a number of local handles.
* After a handle scope has been created, all local handles will be * After a handle scope has been created, all local handles will be

32
test/cctest/test-api.cc
View File

@ -2127,7 +2127,7 @@ THREADED_TEST(InternalFieldsAlignedPointers) {
void* huge = reinterpret_cast<void*>(~static_cast<uintptr_t>(1)); void* huge = reinterpret_cast<void*>(~static_cast<uintptr_t>(1));
CheckAlignedPointerInInternalField(obj, huge); CheckAlignedPointerInInternalField(obj, huge);
v8::UniquePersistent<v8::Object> persistent(isolate, obj); v8::Global<v8::Object> persistent(isolate, obj);
CHECK_EQ(1, Object::InternalFieldCount(persistent)); CHECK_EQ(1, Object::InternalFieldCount(persistent));
CHECK_EQ(huge, Object::GetAlignedPointerFromInternalField(persistent, 0)); CHECK_EQ(huge, Object::GetAlignedPointerFromInternalField(persistent, 0));
} }
@ -3038,20 +3038,20 @@ THREADED_TEST(ResettingGlobalHandleToEmpty) {
template <class T> template <class T>
static v8::UniquePersistent<T> PassUnique(v8::UniquePersistent<T> unique) { static v8::Global<T> PassUnique(v8::Global<T> unique) {
return unique.Pass(); return unique.Pass();
} }
template <class T> template <class T>
static v8::UniquePersistent<T> ReturnUnique(v8::Isolate* isolate, static v8::Global<T> ReturnUnique(v8::Isolate* isolate,
const v8::Persistent<T>& global) { const v8::Persistent<T>& global) {
v8::UniquePersistent<String> unique(isolate, global); v8::Global<String> unique(isolate, global);
return unique.Pass(); return unique.Pass();
} }
THREADED_TEST(UniquePersistent) { THREADED_TEST(Global) {
v8::Isolate* isolate = CcTest::isolate(); v8::Isolate* isolate = CcTest::isolate();
v8::Persistent<String> global; v8::Persistent<String> global;
{ {
@ -3062,11 +3062,11 @@ THREADED_TEST(UniquePersistent) {
reinterpret_cast<v8::internal::Isolate*>(isolate)->global_handles(); reinterpret_cast<v8::internal::Isolate*>(isolate)->global_handles();
int initial_handle_count = global_handles->global_handles_count(); int initial_handle_count = global_handles->global_handles_count();
{ {
v8::UniquePersistent<String> unique(isolate, global); v8::Global<String> unique(isolate, global);
CHECK_EQ(initial_handle_count + 1, global_handles->global_handles_count()); CHECK_EQ(initial_handle_count + 1, global_handles->global_handles_count());
// Test assignment via Pass // Test assignment via Pass
{ {
v8::UniquePersistent<String> copy = unique.Pass(); v8::Global<String> copy = unique.Pass();
CHECK(unique.IsEmpty()); CHECK(unique.IsEmpty());
CHECK(copy == global); CHECK(copy == global);
CHECK_EQ(initial_handle_count + 1, CHECK_EQ(initial_handle_count + 1,
@ -3075,7 +3075,7 @@ THREADED_TEST(UniquePersistent) {
} }
// Test ctor via Pass // Test ctor via Pass
{ {
v8::UniquePersistent<String> copy(unique.Pass()); v8::Global<String> copy(unique.Pass());
CHECK(unique.IsEmpty()); CHECK(unique.IsEmpty());
CHECK(copy == global); CHECK(copy == global);
CHECK_EQ(initial_handle_count + 1, CHECK_EQ(initial_handle_count + 1,
@ -3084,7 +3084,7 @@ THREADED_TEST(UniquePersistent) {
} }
// Test pass through function call // Test pass through function call
{ {
v8::UniquePersistent<String> copy = PassUnique(unique.Pass()); v8::Global<String> copy = PassUnique(unique.Pass());
CHECK(unique.IsEmpty()); CHECK(unique.IsEmpty());
CHECK(copy == global); CHECK(copy == global);
CHECK_EQ(initial_handle_count + 1, CHECK_EQ(initial_handle_count + 1,
@ -3095,7 +3095,7 @@ THREADED_TEST(UniquePersistent) {
} }
// Test pass from function call // Test pass from function call
{ {
v8::UniquePersistent<String> unique = ReturnUnique(isolate, global); v8::Global<String> unique = ReturnUnique(isolate, global);
CHECK(unique == global); CHECK(unique == global);
CHECK_EQ(initial_handle_count + 1, global_handles->global_handles_count()); CHECK_EQ(initial_handle_count + 1, global_handles->global_handles_count());
} }
@ -3129,8 +3129,7 @@ class WeakStdMapTraits : public v8::StdMapTraits<K, V> {
return data.GetParameter()->key; return data.GetParameter()->key;
} }
static void DisposeCallbackData(WeakCallbackDataType* data) { delete data; } static void DisposeCallbackData(WeakCallbackDataType* data) { delete data; }
static void Dispose(v8::Isolate* isolate, v8::UniquePersistent<V> value, static void Dispose(v8::Isolate* isolate, v8::Global<V> value, K key) {}
K key) {}
}; };
@ -3156,7 +3155,7 @@ static void TestPersistentValueMap() {
typename Map::PersistentValueReference ref = map.GetReference(7); typename Map::PersistentValueReference ref = map.GetReference(7);
CHECK(expected->Equals(ref.NewLocal(isolate))); CHECK(expected->Equals(ref.NewLocal(isolate)));
} }
v8::UniquePersistent<v8::Object> removed = map.Remove(7); v8::Global<v8::Object> removed = map.Remove(7);
CHECK_EQ(0, static_cast<int>(map.Size())); CHECK_EQ(0, static_cast<int>(map.Size()));
CHECK(expected == removed); CHECK(expected == removed);
removed = map.Remove(7); removed = map.Remove(7);
@ -3168,8 +3167,7 @@ static void TestPersistentValueMap() {
{ {
typename Map::PersistentValueReference ref; typename Map::PersistentValueReference ref;
Local<v8::Object> expected2 = v8::Object::New(isolate); Local<v8::Object> expected2 = v8::Object::New(isolate);
removed = map.Set(8, v8::UniquePersistent<v8::Object>(isolate, expected2), removed = map.Set(8, v8::Global<v8::Object>(isolate, expected2), &ref);
&ref);
CHECK_EQ(1, static_cast<int>(map.Size())); CHECK_EQ(1, static_cast<int>(map.Size()));
CHECK(expected == removed); CHECK(expected == removed);
CHECK(expected2->Equals(ref.NewLocal(isolate))); CHECK(expected2->Equals(ref.NewLocal(isolate)));
@ -3212,7 +3210,7 @@ TEST(PersistentValueVector) {
Local<v8::Object> obj1 = v8::Object::New(isolate); Local<v8::Object> obj1 = v8::Object::New(isolate);
Local<v8::Object> obj2 = v8::Object::New(isolate); Local<v8::Object> obj2 = v8::Object::New(isolate);
v8::UniquePersistent<v8::Object> obj3(isolate, v8::Object::New(isolate)); v8::Global<v8::Object> obj3(isolate, v8::Object::New(isolate));
CHECK(vector.IsEmpty()); CHECK(vector.IsEmpty());
CHECK_EQ(0, static_cast<int>(vector.Size())); CHECK_EQ(0, static_cast<int>(vector.Size()));