v8-profiler.h   v8-profiler.h 
skipping to change at line 165 skipping to change at line 165
* title are silently ignored. While collecting a profile, functions * title are silently ignored. While collecting a profile, functions
* from all security contexts are included in it. The token-based * from all security contexts are included in it. The token-based
* filtering is only performed when querying for a profile. * filtering is only performed when querying for a profile.
* *
* |record_samples| parameter controls whether individual samples should * |record_samples| parameter controls whether individual samples should
* be recorded in addition to the aggregated tree. * be recorded in addition to the aggregated tree.
*/ */
void StartProfiling(Handle<String> title, bool record_samples = false); void StartProfiling(Handle<String> title, bool record_samples = false);
/** Deprecated. Use StartProfiling instead. */ /** Deprecated. Use StartProfiling instead. */
void StartCpuProfiling(Handle<String> title, bool record_samples = false) V8_DEPRECATED("Use StartProfiling",
; void StartCpuProfiling(Handle<String> title,
bool record_samples = false));
/** /**
* Stops collecting CPU profile with a given title and returns it. * Stops collecting CPU profile with a given title and returns it.
* If the title given is empty, finishes the last profile started. * If the title given is empty, finishes the last profile started.
*/ */
CpuProfile* StopProfiling(Handle<String> title); CpuProfile* StopProfiling(Handle<String> title);
/** Deprecated. Use StopProfiling instead. */ /** Deprecated. Use StopProfiling instead. */
const CpuProfile* StopCpuProfiling(Handle<String> title); V8_DEPRECATED("Use StopProfiling",
const CpuProfile* StopCpuProfiling(Handle<String> title));
/** /**
* Tells the profiler whether the embedder is idle. * Tells the profiler whether the embedder is idle.
*/ */
void SetIdle(bool is_idle); void SetIdle(bool is_idle);
private: private:
CpuProfiler(); CpuProfiler();
~CpuProfiler(); ~CpuProfiler();
CpuProfiler(const CpuProfiler&); CpuProfiler(const CpuProfiler&);
 End of changes. 2 change blocks. 
3 lines changed or deleted 5 lines changed or added


 v8-util.h   v8-util.h 
skipping to change at line 33 skipping to change at line 33
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef V8_UTIL_H_ #ifndef V8_UTIL_H_
#define V8_UTIL_H_ #define V8_UTIL_H_
#include "v8.h" #include "v8.h"
#include <map> #include <map>
#include <vector>
/** /**
* Support for Persistent containers. * Support for Persistent containers.
* *
* C++11 embedders can use STL containers with UniquePersistent values, * C++11 embedders can use STL containers with UniquePersistent values,
* but pre-C++11 does not support the required move semantic and hence * but pre-C++11 does not support the required move semantic and hence
* may want these container classes. * may want these container classes.
*/ */
namespace v8 { namespace v8 {
typedef uintptr_t PersistentContainerValue; typedef uintptr_t PersistentContainerValue;
static const uintptr_t kPersistentContainerNotFound = 0; static const uintptr_t kPersistentContainerNotFound = 0;
enum PersistentContainerCallbackType {
kNotWeak,
kWeak
};
/** /**
* A default trait implemenation for PersistentValueMap which uses std::map * A default trait implemenation for PersistentValueMap which uses std::map
* as a backing map. * as a backing map.
* *
* Users will have to implement their own weak callbacks & dispose traits. * Users will have to implement their own weak callbacks & dispose traits.
*/ */
template<typename K, typename V> template<typename K, typename V>
class StdMapTraits { class StdMapTraits {
public: public:
skipping to change at line 93 skipping to change at line 98
if (it == impl->end()) return kPersistentContainerNotFound; if (it == impl->end()) return kPersistentContainerNotFound;
PersistentContainerValue value = it->second; PersistentContainerValue value = it->second;
impl->erase(it); impl->erase(it);
return value; return value;
} }
}; };
/** /**
* A default trait implementation for PersistentValueMap, which inherits * A default trait implementation for PersistentValueMap, which inherits
* a std:map backing map from StdMapTraits and holds non-weak persistent * a std:map backing map from StdMapTraits and holds non-weak persistent
* objects. * objects and has no special Dispose handling.
* *
* Users have to implement their own dispose trait. * You should not derive from this class, since MapType depends on the
* surrounding class, and hence a subclass cannot simply inherit the method
s.
*/ */
template<typename K, typename V> template<typename K, typename V>
class StrongMapTraits : public StdMapTraits<K, V> { class DefaultPersistentValueMapTraits : public StdMapTraits<K, V> {
public: public:
// Weak callback & friends: // Weak callback & friends:
static const bool kIsWeak = false; static const PersistentContainerCallbackType kCallbackType = kNotWeak;
typedef typename StdMapTraits<K, V>::Impl Impl; typedef PersistentValueMap<K, V, DefaultPersistentValueMapTraits<K, V> >
MapType;
typedef void WeakCallbackDataType; typedef void WeakCallbackDataType;
static WeakCallbackDataType* WeakCallbackParameter( static WeakCallbackDataType* WeakCallbackParameter(
Impl* impl, const K& key, Local<V> value); MapType* map, const K& key, Local<V> value) {
static Impl* ImplFromWeakCallbackData( return NULL;
const WeakCallbackData<V, WeakCallbackDataType>& data); }
static MapType* MapFromWeakCallbackData(
const WeakCallbackData<V, WeakCallbackDataType>& data) {
return NULL;
}
static K KeyFromWeakCallbackData( static K KeyFromWeakCallbackData(
const WeakCallbackData<V, WeakCallbackDataType>& data); const WeakCallbackData<V, WeakCallbackDataType>& data) {
static void DisposeCallbackData(WeakCallbackDataType* data); return K();
}; }
static void DisposeCallbackData(WeakCallbackDataType* data) { }
/** static void Dispose(Isolate* isolate, UniquePersistent<V> value, K key) {
* A default trait implementation for PersistentValueMap, with a std::map }
* backing map, non-weak persistents as values, and no special dispose
* handling. Can be used as-is.
*/
template<typename K, typename V>
class DefaultPersistentValueMapTraits : public StrongMapTraits<K, V> {
public:
typedef typename StrongMapTraits<K, V>::Impl Impl;
static void Dispose(Isolate* isolate, UniquePersistent<V> value,
Impl* impl, K key) { }
}; };
/** /**
* A map wrapper that allows using UniquePersistent as a mapped value. * A map wrapper that allows using UniquePersistent as a mapped value.
* C++11 embedders don't need this class, as they can use UniquePersistent * C++11 embedders don't need this class, as they can use UniquePersistent
* directly in std containers. * directly in std containers.
* *
* The map relies on a backing map, whose type and accessors are described * The map relies on a backing map, whose type and accessors are described
* by the Traits class. The backing map will handle values of type * by the Traits class. The backing map will handle values of type
* PersistentContainerValue, with all conversion into and out of V8 * PersistentContainerValue, with all conversion into and out of V8
skipping to change at line 153 skipping to change at line 155
V8_INLINE Isolate* GetIsolate() { return isolate_; } V8_INLINE Isolate* GetIsolate() { return isolate_; }
/** /**
* Return size of the map. * Return size of the map.
*/ */
V8_INLINE size_t Size() { return Traits::Size(&impl_); } V8_INLINE size_t Size() { return Traits::Size(&impl_); }
/** /**
* Return whether the map holds weak persistents. * Return whether the map holds weak persistents.
*/ */
V8_INLINE bool IsWeak() { return Traits::kIsWeak; } V8_INLINE bool IsWeak() { return Traits::kCallbackType != kNotWeak; }
/** /**
* Get value stored in map. * Get value stored in map.
*/ */
V8_INLINE Local<V> Get(const K& key) { V8_INLINE Local<V> Get(const K& key) {
return Local<V>::New(isolate_, FromVal(Traits::Get(&impl_, key))); return Local<V>::New(isolate_, FromVal(Traits::Get(&impl_, key)));
} }
/** /**
* Check whether a value is contained in the map. * Check whether a value is contained in the map.
*/ */
V8_INLINE bool Contains(const K& key) { V8_INLINE bool Contains(const K& key) {
return Traits::Get(&impl_, key) != 0; return Traits::Get(&impl_, key) != kPersistentContainerNotFound;
} }
/** /**
* Get value stored in map and set it in returnValue. * Get value stored in map and set it in returnValue.
* Return true if a value was found. * Return true if a value was found.
*/ */
V8_INLINE bool SetReturnValue(const K& key, V8_INLINE bool SetReturnValue(const K& key,
ReturnValue<Value>& returnValue) { ReturnValue<Value> returnValue) {
PersistentContainerValue value = Traits::Get(&impl_, key); return SetReturnValueFromVal(returnValue, Traits::Get(&impl_, key));
bool hasValue = value != 0;
if (hasValue) {
returnValue.SetInternal(
*reinterpret_cast<internal::Object**>(FromVal(value)));
}
return hasValue;
} }
/** /**
* Call Isolate::SetReference with the given parent and the map value. * Call Isolate::SetReference with the given parent and the map value.
*/ */
V8_INLINE void SetReference(const K& key, V8_INLINE void SetReference(const K& key,
const Persistent<Object>& parent) { const Persistent<Object>& parent) {
GetIsolate()->SetReference( GetIsolate()->SetReference(
reinterpret_cast<internal::Object**>(parent.val_), reinterpret_cast<internal::Object**>(parent.val_),
reinterpret_cast<internal::Object**>(FromVal(Traits::Get(&impl_, key) ))); reinterpret_cast<internal::Object**>(FromVal(Traits::Get(&impl_, key) )));
skipping to change at line 230 skipping to change at line 226
* in case side effects of disposal cause insertions. * in case side effects of disposal cause insertions.
**/ **/
void Clear() { void Clear() {
typedef typename Traits::Iterator It; typedef typename Traits::Iterator It;
HandleScope handle_scope(isolate_); HandleScope handle_scope(isolate_);
// TODO(dcarney): figure out if this swap and loop is necessary. // TODO(dcarney): figure out if this swap and loop is necessary.
while (!Traits::Empty(&impl_)) { while (!Traits::Empty(&impl_)) {
typename Traits::Impl impl; typename Traits::Impl impl;
Traits::Swap(impl_, impl); Traits::Swap(impl_, impl);
for (It i = Traits::Begin(&impl); i != Traits::End(&impl); ++i) { for (It i = Traits::Begin(&impl); i != Traits::End(&impl); ++i) {
Traits::Dispose(isolate_, Release(Traits::Value(i)).Pass(), &impl, Traits::Dispose(isolate_, Release(Traits::Value(i)).Pass(),
Traits::Key(i)); Traits::Key(i));
} }
} }
} }
/**
* Helper class for GetReference/SetWithReference. Do not use outside
* that context.
*/
class PersistentValueReference {
public:
PersistentValueReference() : value_(kPersistentContainerNotFound) { }
PersistentValueReference(const PersistentValueReference& other)
: value_(other.value_) { }
Local<V> NewLocal(Isolate* isolate) const {
return Local<V>::New(isolate, FromVal(value_));
}
bool IsEmpty() const {
return value_ == kPersistentContainerNotFound;
}
template<typename T>
bool SetReturnValue(ReturnValue<T> returnValue) {
return SetReturnValueFromVal(returnValue, value_);
}
void Reset() {
value_ = kPersistentContainerNotFound;
}
void operator=(const PersistentValueReference& other) {
value_ = other.value_;
}
private:
friend class PersistentValueMap;
explicit PersistentValueReference(PersistentContainerValue value)
: value_(value) { }
void operator=(PersistentContainerValue value) {
value_ = value;
}
PersistentContainerValue value_;
};
/**
* Get a reference to a map value. This enables fast, repeated access
* to a value stored in the map while the map remains unchanged.
*
* Careful: This is potentially unsafe, so please use with care.
* The value will become invalid if the value for this key changes
* in the underlying map, as a result of Set or Remove for the same
* key; as a result of the weak callback for the same key; or as a
* result of calling Clear() or destruction of the map.
*/
V8_INLINE PersistentValueReference GetReference(const K& key) {
return PersistentValueReference(Traits::Get(&impl_, key));
}
/**
* Put a value into the map and update the reference.
* Restrictions of GetReference apply here as well.
*/
UniquePersistent<V> Set(const K& key, UniquePersistent<V> value,
PersistentValueReference* reference) {
*reference = Leak(&value);
return SetUnique(key, &value);
}
private: private:
PersistentValueMap(PersistentValueMap&); PersistentValueMap(PersistentValueMap&);
void operator=(PersistentValueMap&); void operator=(PersistentValueMap&);
/** /**
* Put the value into the map, and set the 'weak' callback when demanded * Put the value into the map, and set the 'weak' callback when demanded
* by the Traits class. * by the Traits class.
*/ */
UniquePersistent<V> SetUnique(const K& key, UniquePersistent<V>* persiste nt) { UniquePersistent<V> SetUnique(const K& key, UniquePersistent<V>* persiste nt) {
if (Traits::kIsWeak) { if (Traits::kCallbackType != kNotWeak) {
Local<V> value(Local<V>::New(isolate_, *persistent)); Local<V> value(Local<V>::New(isolate_, *persistent));
persistent->template SetWeak<typename Traits::WeakCallbackDataType>( persistent->template SetWeak<typename Traits::WeakCallbackDataType>(
Traits::WeakCallbackParameter(&impl_, key, value), WeakCallback); Traits::WeakCallbackParameter(this, key, value), WeakCallback);
} }
PersistentContainerValue old_value = PersistentContainerValue old_value =
Traits::Set(&impl_, key, ClearAndLeak(persistent)); Traits::Set(&impl_, key, ClearAndLeak(persistent));
return Release(old_value).Pass(); return Release(old_value).Pass();
} }
static void WeakCallback( static void WeakCallback(
const WeakCallbackData<V, typename Traits::WeakCallbackDataType>& dat a) { const WeakCallbackData<V, typename Traits::WeakCallbackDataType>& dat a) {
if (Traits::kIsWeak) { if (Traits::kCallbackType != kNotWeak) {
typename Traits::Impl* impl = Traits::ImplFromWeakCallbackData(data); PersistentValueMap<K, V, Traits>* persistentValueMap =
Traits::MapFromWeakCallbackData(data);
K key = Traits::KeyFromWeakCallbackData(data); K key = Traits::KeyFromWeakCallbackData(data);
PersistentContainerValue value = Traits::Remove(impl, key); Traits::Dispose(data.GetIsolate(),
Traits::Dispose(data.GetIsolate(), Release(value).Pass(), impl, key); persistentValueMap->Remove(key).Pass(), key);
} }
} }
V8_INLINE static V* FromVal(PersistentContainerValue v) { V8_INLINE static V* FromVal(PersistentContainerValue v) {
return reinterpret_cast<V*>(v); return reinterpret_cast<V*>(v);
} }
V8_INLINE static bool SetReturnValueFromVal(
ReturnValue<Value>& returnValue, PersistentContainerValue value) {
bool hasValue = value != kPersistentContainerNotFound;
if (hasValue) {
returnValue.SetInternal(
*reinterpret_cast<internal::Object**>(FromVal(value)));
}
return hasValue;
}
V8_INLINE static PersistentContainerValue ClearAndLeak( V8_INLINE static PersistentContainerValue ClearAndLeak(
UniquePersistent<V>* persistent) { UniquePersistent<V>* persistent) {
V* v = persistent->val_; V* v = persistent->val_;
persistent->val_ = 0; persistent->val_ = 0;
return reinterpret_cast<PersistentContainerValue>(v); return reinterpret_cast<PersistentContainerValue>(v);
} }
V8_INLINE static PersistentContainerValue Leak(
UniquePersistent<V>* persistent) {
return reinterpret_cast<PersistentContainerValue>(persistent->val_);
}
/** /**
* Return a container value as UniquePersistent and make sure the weak * Return a container value as UniquePersistent and make sure the weak
* callback is properly disposed of. All remove functionality should go * callback is properly disposed of. All remove functionality should go
* through this. * through this.
*/ */
V8_INLINE static UniquePersistent<V> Release(PersistentContainerValue v) { V8_INLINE static UniquePersistent<V> Release(PersistentContainerValue v) {
UniquePersistent<V> p; UniquePersistent<V> p;
p.val_ = FromVal(v); p.val_ = FromVal(v);
if (Traits::kIsWeak && !p.IsEmpty()) { if (Traits::kCallbackType != kNotWeak && !p.IsEmpty()) {
Traits::DisposeCallbackData( Traits::DisposeCallbackData(
p.template ClearWeak<typename Traits::WeakCallbackDataType>()); p.template ClearWeak<typename Traits::WeakCallbackDataType>());
} }
return p.Pass(); return p.Pass();
} }
Isolate* isolate_; Isolate* isolate_;
typename Traits::Impl impl_; typename Traits::Impl impl_;
}; };
skipping to change at line 310 skipping to change at line 386
* UniquePersistent directly in std containers. * UniquePersistent directly in std containers.
*/ */
template<typename K, typename V, template<typename K, typename V,
typename Traits = DefaultPersistentValueMapTraits<K, V> > typename Traits = DefaultPersistentValueMapTraits<K, V> >
class StdPersistentValueMap : public PersistentValueMap<K, V, Traits> { class StdPersistentValueMap : public PersistentValueMap<K, V, Traits> {
public: public:
explicit StdPersistentValueMap(Isolate* isolate) explicit StdPersistentValueMap(Isolate* isolate)
: PersistentValueMap<K, V, Traits>(isolate) {} : PersistentValueMap<K, V, Traits>(isolate) {}
}; };
class DefaultPersistentValueVectorTraits {
public:
typedef std::vector<PersistentContainerValue> Impl;
static void Append(Impl* impl, PersistentContainerValue value) {
impl->push_back(value);
}
static bool IsEmpty(const Impl* impl) {
return impl->empty();
}
static size_t Size(const Impl* impl) {
return impl->size();
}
static PersistentContainerValue Get(const Impl* impl, size_t i) {
return (i < impl->size()) ? impl->at(i) : kPersistentContainerNotFound;
}
static void ReserveCapacity(Impl* impl, size_t capacity) {
impl->reserve(capacity);
}
static void Clear(Impl* impl) {
impl->clear();
}
};
/** /**
* Empty default implementations for StrongTraits methods. * A vector wrapper that safely stores UniquePersistent values.
* * C++11 embedders don't need this class, as they can use UniquePersistent
* These should not be necessary, since they're only used in code that * directly in std containers.
* is surrounded by if(Traits::kIsWeak), which for StrongMapTraits is
* compile-time false. Most compilers can live without them; however
* the compiler we use from 64-bit Win differs.
* *
* TODO(vogelheim): Remove these once they're no longer necessary. * This class relies on a backing vector implementation, whose type and met
hods
* are described by the Traits class. The backing map will handle values of
type
* PersistentContainerValue, with all conversion into and out of V8
* handles being transparently handled by this class.
*/ */
template<typename K, typename V> template<typename V, typename Traits = DefaultPersistentValueVectorTraits>
typename StrongMapTraits<K, V>::WeakCallbackDataType* class PersistentValueVector {
StrongMapTraits<K, V>::WeakCallbackParameter( public:
Impl* impl, const K& key, Local<V> value) { explicit PersistentValueVector(Isolate* isolate) : isolate_(isolate) { }
return NULL;
}
template<typename K, typename V> ~PersistentValueVector() {
typename StrongMapTraits<K, V>::Impl* Clear();
StrongMapTraits<K, V>::ImplFromWeakCallbackData( }
const WeakCallbackData<V, WeakCallbackDataType>& data) {
return NULL;
}
template<typename K, typename V> /**
K StrongMapTraits<K, V>::KeyFromWeakCallbackData( * Append a value to the vector.
const WeakCallbackData<V, WeakCallbackDataType>& data) { */
return K(); void Append(Local<V> value) {
} UniquePersistent<V> persistent(isolate_, value);
Traits::Append(&impl_, ClearAndLeak(&persistent));
}
template<typename K, typename V> /**
void StrongMapTraits<K, V>::DisposeCallbackData(WeakCallbackDataType* data) * Append a persistent's value to the vector.
{ */
} void Append(UniquePersistent<V> persistent) {
Traits::Append(&impl_, ClearAndLeak(&persistent));
};
/**
* Are there any values in the vector?
*/
bool IsEmpty() const {
return Traits::IsEmpty(&impl_);
}
/**
* How many elements are in the vector?
*/
size_t Size() const {
return Traits::Size(&impl_);
}
/**
* Retrieve the i-th value in the vector.
*/
Local<V> Get(size_t index) const {
return Local<V>::New(isolate_, FromVal(Traits::Get(&impl_, index)));
}
/**
* Remove all elements from the vector.
*/
void Clear() {
size_t length = Traits::Size(&impl_);
for (size_t i = 0; i < length; i++) {
UniquePersistent<V> p;
p.val_ = FromVal(Traits::Get(&impl_, i));
}
Traits::Clear(&impl_);
}
/**
* Reserve capacity in the vector.
* (Efficiency gains depend on the backing implementation.)
*/
void ReserveCapacity(size_t capacity) {
Traits::ReserveCapacity(&impl_, capacity);
}
private:
static PersistentContainerValue ClearAndLeak(
UniquePersistent<V>* persistent) {
V* v = persistent->val_;
persistent->val_ = 0;
return reinterpret_cast<PersistentContainerValue>(v);
}
static V* FromVal(PersistentContainerValue v) {
return reinterpret_cast<V*>(v);
}
Isolate* isolate_;
typename Traits::Impl impl_;
};
} // namespace v8 } // namespace v8
#endif // V8_UTIL_H_ #endif // V8_UTIL_H_
 End of changes. 28 change blocks. 
70 lines changed or deleted 230 lines changed or added


 v8.h   v8.h 
skipping to change at line 132 skipping to change at line 132
class Value; class Value;
template <class T> class Handle; template <class T> class Handle;
template <class T> class Local; template <class T> class Local;
template <class T> class Eternal; template <class T> class Eternal;
template<class T> class NonCopyablePersistentTraits; 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 UniquePersistent;
template<class K, class V, class T> class PersistentValueMap; template<class K, class V, class T> class PersistentValueMap;
template<class V, class T> class PersistentValueVector;
template<class T, class P> class WeakCallbackObject; template<class T, class P> class WeakCallbackObject;
class FunctionTemplate; class FunctionTemplate;
class ObjectTemplate; class ObjectTemplate;
class Data; class Data;
template<typename T> class FunctionCallbackInfo; template<typename T> class FunctionCallbackInfo;
template<typename T> class PropertyCallbackInfo; template<typename T> class PropertyCallbackInfo;
class StackTrace; class StackTrace;
class StackFrame; class StackFrame;
class Isolate; class Isolate;
class DeclaredAccessorDescriptor; class DeclaredAccessorDescriptor;
skipping to change at line 416 skipping to change at line 417
template<class F> friend class Local; template<class F> friend class Local;
template<class F> friend class FunctionCallbackInfo; template<class F> friend class FunctionCallbackInfo;
template<class F> friend class PropertyCallbackInfo; template<class F> friend class PropertyCallbackInfo;
friend class String; friend class String;
friend class Object; friend class Object;
friend class Context; friend class Context;
template<class F> friend class internal::CustomArguments; template<class F> friend class internal::CustomArguments;
friend class HandleScope; friend class HandleScope;
friend class EscapableHandleScope; friend class EscapableHandleScope;
template<class F1, class F2, class F3> friend class PersistentValueMap; template<class F1, class F2, class F3> friend class PersistentValueMap;
template<class F1, class F2> friend class PersistentValueVector;
V8_INLINE static Local<T> New(Isolate* isolate, T* that); V8_INLINE static Local<T> New(Isolate* isolate, T* that);
}; };
// Eternal handles are set-once handles that live for the life of the isola te. // Eternal handles are set-once handles that live for the life of the isola te.
template <class T> class Eternal { template <class T> class Eternal {
public: public:
V8_INLINE Eternal() : index_(kInitialValue) { } V8_INLINE Eternal() : index_(kInitialValue) { }
template<class S> template<class S>
V8_INLINE Eternal(Isolate* isolate, Local<S> handle) : index_(kInitialVal ue) { V8_INLINE Eternal(Isolate* isolate, Local<S> handle) : index_(kInitialVal ue) {
skipping to change at line 582 skipping to change at line 584
private: private:
friend class Isolate; friend class Isolate;
friend class Utils; friend class Utils;
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 UniquePersistent;
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> friend class PersistentValueMap; template<class F1, class F2, class F3> friend class PersistentValueMap;
template<class F1, class F2> friend class PersistentValueVector;
friend class Object; friend class Object;
explicit V8_INLINE PersistentBase(T* val) : val_(val) {} explicit V8_INLINE PersistentBase(T* val) : val_(val) {}
PersistentBase(PersistentBase& other); // NOLINT PersistentBase(PersistentBase& other); // NOLINT
void operator=(PersistentBase&); void operator=(PersistentBase&);
V8_INLINE static T* New(Isolate* isolate, T* that); V8_INLINE static T* New(Isolate* isolate, T* that);
T* val_; T* val_;
}; };
 End of changes. 3 change blocks. 
0 lines changed or deleted 3 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/