is cleared as a result of all other handles to that v8object being released.
See QV8GCCallback::garbageCollectorPrologueCallback() for more information.
*/
-void QQmlVMEMetaObject::VarPropertiesWeakReferenceCallback(v8::Persistent<v8::Value> object, void* parameter)
+void QQmlVMEMetaObject::VarPropertiesWeakReferenceCallback(QV4::PersistentValue &object, void* parameter)
{
+ // ### FIXME
QQmlVMEMetaObject *vmemo = static_cast<QQmlVMEMetaObject*>(parameter);
Q_ASSERT(vmemo);
- qPersistentDispose(object);
+ object.clear();
vmemo->varProperties.clear();
}
QV4::PersistentValue varProperties;
int firstVarPropertyIndex;
bool varPropertiesInitialized;
- static void VarPropertiesWeakReferenceCallback(v8::Persistent<v8::Value> object, void* parameter);
+ static void VarPropertiesWeakReferenceCallback(QV4::PersistentValue &object, void* parameter);
static void GcPrologueCallback(QV8GCCallback::Node *node);
inline void allocateVarPropertiesArray();
inline bool ensureVarPropertiesAllocated();
struct V8AccessorGetter: FunctionObject {
AccessorGetter getter;
- Persistent<Value> data;
- Persistent<String> name;
+ QV4::PersistentValue data;
+ QV4::PersistentValue name;
V8AccessorGetter(ExecutionContext *scope, const Handle<String> &name, const AccessorGetter &getter, Handle<Value> data)
: FunctionObject(scope)
{
vtbl = &static_vtbl;
this->getter = getter;
- this->data = Persistent<Value>::New(data);
- this->name = Persistent<String>::New(name);
+ this->data = data->v4Value();
+ this->name = name->v4Value();
}
using Object::construct;
static QV4::Value call(Managed *that, ExecutionContext *context, const QV4::Value &thisObject, QV4::Value *args, int argc)
{
V8AccessorGetter *getter = static_cast<V8AccessorGetter*>(that);
- AccessorInfo info(thisObject, getter->data);
+ AccessorInfo info(thisObject, getter->data.value());
QV4::Value result = QV4::Value::undefinedValue();
try {
- result = getter->getter(getter->name, info)->v4Value();
+ result = getter->getter(getter->name.value(), info)->v4Value();
} catch (QV4::Exception &e) {
Isolate::GetCurrent()->setException(e.value());
e.accept(context);
struct V8AccessorSetter: FunctionObject {
AccessorSetter setter;
- Persistent<Value> data;
- Persistent<String> name;
+ QV4::PersistentValue data;
+ QV4::PersistentValue name;
V8AccessorSetter(ExecutionContext *scope, const Handle<String> &name, const AccessorSetter &setter, Handle<Value> data)
: FunctionObject(scope)
{
vtbl = &static_vtbl;
this->setter = setter;
- this->data = Persistent<Value>::New(data);
- this->name = Persistent<String>::New(name);
+ this->data = data->v4Value();
+ this->name = name->v4Value();
}
using Object::construct;
if (!argc)
return QV4::Value::undefinedValue();
V8AccessorSetter *setter = static_cast<V8AccessorSetter*>(that);
- AccessorInfo info(thisObject, setter->data);
+ AccessorInfo info(thisObject, setter->data.value());
try {
- setter->setter(setter->name, args[0], info);
+ setter->setter(setter->name.value(), args[0], info);
} catch (QV4::Exception &e) {
Isolate::GetCurrent()->setException(e.value());
e.accept(context);
Handle<String> StackFrame::GetScriptName() const
{
- return m_scriptName;
+ return m_scriptName.value();
}
Handle<String> StackFrame::GetScriptNameOrSourceURL() const
{
- return m_scriptName;
+ return m_scriptName.value();
}
Handle<String> StackFrame::GetFunctionName() const
{
- return m_functionName;
+ return m_functionName.value();
}
StackFrame::StackFrame(Handle<String> script, Handle<String> function, int line, int column)
: m_lineNumber(line)
, m_columnNumber(column)
{
- m_scriptName = Persistent<String>::New(script);
- m_functionName = Persistent<String>::New(function);
+ m_scriptName = script->v4Value();
+ m_functionName = function->v4Value();
}
void Template::Set(Handle<String> name, Handle<Value> value, PropertyAttribute attributes)
{
Property p;
- p.name = Persistent<String>::New(name);
- p.value = Persistent<Value>::New(value);
+ p.name = name->v4Value();
+ p.value = value->v4Value();
p.attributes = attributes;
m_properties << p;
}
}
-Arguments::Arguments(const QV4::Value *args, int argc, const QV4::Value &thisObject, bool isConstructor, const Persistent<Value> &data)
+Arguments::Arguments(const QV4::Value *args, int argc, const QV4::Value &thisObject, bool isConstructor, const Handle<Value> &data)
{
for (int i = 0; i < argc; ++i)
- m_args << Persistent<Value>::New(Value::fromV4Value(args[i]));
- m_thisObject = Persistent<Object>::New(Value::fromV4Value(thisObject));
+ m_args << args[i];
+ m_thisObject = thisObject;
m_isConstructor = isConstructor;
- m_data = Persistent<Value>::New(data);
+ m_data = data->v4Value();
}
int Arguments::Length() const
Handle<Value> Arguments::operator [](int i) const
{
- return m_args.at(i);
+ return m_args.at(i).value();
}
Handle<Object> Arguments::This() const
{
- return m_thisObject;
+ return m_thisObject.value();
}
QV4::Value Arguments::ThisV4() const
{
- return m_thisObject->v4Value();
+ return m_thisObject;
}
Handle<Object> Arguments::Holder() const
{
// ### FIXME.
- return m_thisObject;
+ return m_thisObject.value();
}
bool Arguments::IsConstructCall() const
Handle<Value> Arguments::Data() const
{
- return m_data;
+ return m_data.value();
}
Isolate *Arguments::GetIsolate() const
}
-AccessorInfo::AccessorInfo(const QV4::Value &thisObject, const Persistent<Value> &data)
+AccessorInfo::AccessorInfo(const QV4::Value &thisObject, const Handle<Value> &data)
{
- m_this = Persistent<Object>::New(Value::fromV4Value(thisObject));
- m_data = data;
+ m_this = thisObject;
+ m_data = data->v4Value();
}
Isolate *AccessorInfo::GetIsolate() const
Handle<Value> AccessorInfo::Data() const
{
- return m_data;
+ return m_data.value();
}
Handle<Object> AccessorInfo::This() const
{
- return m_this;
+ return m_this.value();
}
Handle<Object> AccessorInfo::Holder() const
{
// ### FIXME
- return m_this;
+ return m_this.value();
}
template <typename BaseClass>
: BaseClass(engine->rootContext)
{
this->vtbl = &static_vtbl;
- m_template = Persistent<ObjectTemplate>(tmpl);
- if (m_template.IsEmpty())
- m_template = Persistent<ObjectTemplate>::New(ObjectTemplate::New());
+ m_template = tmpl;
+ if (!m_template)
+ m_template = ObjectTemplate::New().get();
foreach (const ObjectTemplate::Accessor &acc, m_template->m_accessors) {
PropertyAttributes attrs = Attr_Accessor;
attrs.setConfigurable(!(acc.attribute & DontDelete));
attrs.setEnumerable(!(acc.attribute & DontEnum));
- QV4::Property *pd = this->insertMember(acc.name->asV4String(), attrs);
- *pd = QV4::Property::fromAccessor(acc.getter->v4Value().asFunctionObject(),
- acc.setter->v4Value().asFunctionObject());
+ QV4::Property *pd = this->insertMember(acc.name.value().asString(), attrs);
+ *pd = QV4::Property::fromAccessor(acc.getter.value().asFunctionObject(),
+ acc.setter.value().asFunctionObject());
}
- initProperties(m_template.get());
+ initProperties(m_template.data());
}
void initProperties(Template *tmpl)
attrs.setConfigurable(!(p.attributes & DontDelete));
attrs.setEnumerable(!(p.attributes & DontEnum));
attrs.setWritable(!(p.attributes & ReadOnly));
- QV4::Property *pd = this->insertMember(p.name->asV4String(), attrs);
- *pd = QV4::Property::fromValue(p.value->v4Value());
+ QV4::Property *pd = this->insertMember(p.name.value().asString(), attrs);
+ *pd = QV4::Property::fromValue(p.value);
}
}
- Persistent<ObjectTemplate> m_template;
+ QExplicitlySharedDataPointer<ObjectTemplate> m_template;
protected:
AccessorInfo namedAccessorInfo()
{
// ### thisObject?
- return AccessorInfo(QV4::Value::fromObject(this), m_template->m_namedPropertyData);
+ return AccessorInfo(QV4::Value::fromObject(this), m_template->m_namedPropertyData.value());
}
AccessorInfo fallbackAccessorInfo()
{
// ### thisObject?
- return AccessorInfo(QV4::Value::fromObject(this), m_template->m_fallbackPropertyData);
+ return AccessorInfo(QV4::Value::fromObject(this), m_template->m_fallbackPropertyData.value());
}
AccessorInfo indexedAccessorInfo()
{
// ### thisObject?
- return AccessorInfo(QV4::Value::fromObject(this), m_template->m_namedPropertyData);
+ return AccessorInfo(QV4::Value::fromObject(this), m_template->m_namedPropertyData.value());
}
static const ManagedVTable static_vtbl;
: V4V8Object<QV4::FunctionObject>(engine, 0)
{
vtbl = &static_vtbl;
- m_functionTemplate = Persistent<FunctionTemplate>(functionTemplate);
- initProperties(m_functionTemplate.get());
+ m_functionTemplate = functionTemplate;
+ initProperties(m_functionTemplate.data());
}
protected:
static QV4::Value call(QV4::Managed *m, ExecutionContext *context, const QV4::Value &thisObject, QV4::Value *args, int argc)
{
V4V8Function *that = static_cast<V4V8Function*>(m);
- Arguments arguments(args, argc, thisObject, false, that->m_functionTemplate->m_data);
+ Arguments arguments(args, argc, thisObject, false, that->m_functionTemplate->m_data.value());
QV4::Value result = QV4::Value::undefinedValue();
if (that->m_functionTemplate->m_callback)
result = that->m_functionTemplate->m_callback(arguments);
static QV4::Value construct(QV4::Managed *m, ExecutionContext *context, QV4::Value *args, int argc)
{
V4V8Function *that = static_cast<V4V8Function*>(m);
- Arguments arguments(args, argc, QV4::Value::undefinedValue(), true, that->m_functionTemplate->m_data);
+ Arguments arguments(args, argc, QV4::Value::undefinedValue(), true, that->m_functionTemplate->m_data.value());
QV4::Object *obj = that->m_functionTemplate->InstanceTemplate()->NewInstance()->v4Value().asObject();
QV4::Value proto = that->Managed::get(context, context->engine->id_prototype);
}
- Persistent<FunctionTemplate> m_functionTemplate;
+ QExplicitlySharedDataPointer<FunctionTemplate> m_functionTemplate;
};
DEFINE_MANAGED_VTABLE(V4V8Function);
{
m_instanceTemplate = Handle<ObjectTemplate>();
m_prototypeTemplate = Handle<ObjectTemplate>();
- m_data = Persistent<Value>::New(data);
+ m_data = data->v4Value();
}
FunctionTemplate::FunctionTemplate(NewInvocationCallback callback, Handle<Value> data)
{
m_instanceTemplate = Handle<ObjectTemplate>();
m_prototypeTemplate = Handle<ObjectTemplate>();
- m_data = Persistent<Value>::New(data);
+ m_data = data->v4Value();
}
Handle<FunctionTemplate> FunctionTemplate::New(InvocationCallback callback, Handle<Value> data)
Accessor a;
if (getter) {
QV4::FunctionObject *wrappedGetter = new (engine->memoryManager) V8AccessorGetter(engine->rootContext, name, getter, data);
- a.getter = Persistent<Value>::New(Value::fromV4Value(QV4::Value::fromObject(wrappedGetter)));
+ a.getter = QV4::Value::fromObject(wrappedGetter);
}
if (setter) {
QV4::FunctionObject *wrappedSetter = new (engine->memoryManager) V8AccessorSetter(engine->rootContext, name, setter, data);
- a.setter = Persistent<Value>::New(Value::fromV4Value(QV4::Value::fromObject(wrappedSetter)));
+ a.setter = QV4::Value::fromObject(wrappedSetter);
}
a.attribute = attribute;
- a.name = Persistent<String>::New(name);
+ a.name = name->v4Value();
m_accessors << a;
}
m_namedPropertyQuery = query;
m_namedPropertyDeleter = deleter;
m_namedPropertyEnumerator = enumerator;
- m_namedPropertyData = Persistent<Value>::New(data);
+ m_namedPropertyData = data->v4Value();
}
void ObjectTemplate::SetFallbackPropertyHandler(NamedPropertyGetter getter, NamedPropertySetter setter, NamedPropertyQuery query, NamedPropertyDeleter deleter, NamedPropertyEnumerator enumerator, Handle<Value> data)
m_fallbackPropertyQuery = query;
m_fallbackPropertyDeleter = deleter;
m_fallbackPropertyEnumerator = enumerator;
- m_fallbackPropertyData = Persistent<Value>::New(data);
+ m_fallbackPropertyData = data->v4Value();
}
void ObjectTemplate::SetIndexedPropertyHandler(IndexedPropertyGetter getter, IndexedPropertySetter setter, IndexedPropertyQuery query, IndexedPropertyDeleter deleter, IndexedPropertyEnumerator enumerator, Handle<Value> data)
m_indexedPropertyQuery = query;
m_indexedPropertyDeleter = deleter;
m_indexedPropertyEnumerator = enumerator;
- m_indexedPropertyData = Persistent<Value>::New(data);
+ m_indexedPropertyData = data->v4Value();
}
int ObjectTemplate::InternalFieldCount()
assert(!"RemoveGCPrologueCallback();");
}
-void V8::AddImplicitReferences(Persistent<Object> parent, Persistent<Value> *children, size_t length)
-{
- // not required currently as we don't have weak Persistent references.
- // not having them will lead to some leaks in QQmlVMEMetaObejct, but shouldn't matter otherwise
- assert(!"AddImplicitReferences();");
-}
+//void V8::AddImplicitReferences(Persistent<Object> parent, QV4::PersistentValue *children, size_t length)
+//{
+// // not required currently as we don't have weak Persistent references.
+// // not having them will lead to some leaks in QQmlVMEMetaObejct, but shouldn't matter otherwise
+// assert(!"AddImplicitReferences();");
+//}
TryCatch::TryCatch()
#include "qv4global_p.h"
#include "qv4string_p.h"
+#include "qv4value_p.h"
#include <QStack>
#include <QSharedData>
class Signature;
class AccessorSignature;
template <class T> struct Handle;
-template <class T> class Persistent;
class FunctionTemplate;
class ObjectTemplate;
class Data;
* \param object the weak global object to be reclaimed by the garbage collector
* \param parameter the value passed in when making the weak global object
*/
-typedef void (*WeakReferenceCallback)(Persistent<Value> object,
- void* parameter);
+//typedef void (*WeakReferenceCallback)(Persistent<Value> object,
+// void* parameter);
// --- Handles ---
};
};
-
-/**
- * An object reference that is independent of any handle scope. Where
- * a Local handle only lives as long as the HandleScope in which it was
- * allocated, a Persistent handle remains valid until it is explicitly
- * disposed.
- *
- * A persistent handle contains a reference to a storage cell within
- * the v8 engine which holds an object value and which is updated by
- * the garbage collector whenever the object is moved. A new storage
- * cell can be created using Persistent::New and existing handles can
- * be disposed using Persistent::Dispose. Since persistent handles
- * are passed by value you may have many persistent handle objects
- * that point to the same storage cell. For instance, if you pass a
- * persistent handle as an argument to a function you will not get two
- * different storage cells but rather two references to the same
- * storage cell.
- */
-template <class T> class Persistent : public Handle<T> {
- public:
- /**
- * Creates an empty persistent handle that doesn't point to any
- * storage cell.
- */
- Persistent() {}
- ~Persistent() {
- HandleOperations<T>::unProtect(m_memoryManager, this);
- }
-
- Persistent(const Persistent &other)
- : Handle<T>(other)
- , m_memoryManager(other.m_memoryManager)
- {
- HandleOperations<T>::protect(m_memoryManager, this);
- }
-
- Persistent &operator =(const Persistent &other)
- {
- if (&other == this)
- return *this;
- HandleOperations<T>::unProtect(m_memoryManager, this);
- Handle<T>::operator =(other);
- m_memoryManager = other.m_memoryManager;
- HandleOperations<T>::protect(m_memoryManager, this);
- return *this;
- }
-
- /**
- * Creates a persistent handle for the same storage cell as the
- * specified handle. This constructor allows you to pass persistent
- * handles as arguments by value and to assign between persistent
- * handles. However, attempting to assign between incompatible
- * persistent handles, for instance from a Persistent<String> to a
- * Persistent<Number> will cause a compile-time error. Assigning
- * between compatible persistent handles, for instance assigning a
- * Persistent<String> to a variable declared as Persistent<Value>,
- * is allowed as String is a subclass of Value.
- */
- template <class S> Persistent(Persistent<S> that)
- : Handle<T>(Handle<T>::Cast(that)) {
- m_memoryManager = that.m_memoryManager;
- HandleOperations<T>::protect(m_memoryManager, this);
- }
-
- template <class S> Persistent(S* that) : Handle<T>(that)
- {
- m_memoryManager = HandleOperations<T>::protect(this);
- }
-
- /**
- * "Casts" a plain handle which is known to be a persistent handle
- * to a persistent handle.
- */
- template <class S> explicit Persistent(Handle<S> that)
- : Handle<T>(*that)
- {
- m_memoryManager = HandleOperations<T>::protect(this);
- }
-
- template <class S> static Persistent<T> Cast(Persistent<S> that) {
- return Persistent<T>(T::Cast(*that));
- }
-
- template <class S> Persistent<S> As() {
- return Persistent<S>::Cast(*this);
- }
-
- /**
- * Creates a new persistent handle for an existing local or
- * persistent handle.
- */
- static Persistent<T> New(Handle<T> that)
- {
- Persistent<T> result;
- result.Handle<T>::operator =(that);
- result.m_memoryManager = HandleOperations<T>::protect(&result);
- return result;
- }
-
- /**
- * Releases the storage cell referenced by this persistent handle.
- * Does not remove the reference to the cell from any handles.
- * This handle's reference, and any other references to the storage
- * cell remain and IsEmpty will still return false.
- */
- void Dispose() {
- HandleOperations<T>::unProtect(m_memoryManager, this);
- m_memoryManager = 0;
- HandleOperations<T>::deref(this);
- HandleOperations<T>::init(this);
- }
-
- /**
- * Make the reference to this object weak. When only weak handles
- * refer to the object, the garbage collector will perform a
- * callback to the given V8::WeakReferenceCallback function, passing
- * it the object reference and the given parameters.
- */
- void MakeWeak(void* parameters, WeakReferenceCallback callback);
-public:
- void *m_memoryManager;
-};
-
-
// --- Special objects ---
StackFrame(Handle<String> script, Handle<String> function, int line, int column);
int m_lineNumber;
int m_columnNumber;
- Persistent<String> m_scriptName;
- Persistent<String> m_functionName;
+ QV4::PersistentValue m_scriptName;
+ QV4::PersistentValue m_functionName;
};
DEFINE_REFCOUNTED_HANDLE_OPERATIONS(StackFrame)
void Set(const char* name, Handle<Value> value);
struct Property {
- Persistent<String> name;
- Persistent<Value> value;
+ QV4::PersistentValue name;
+ QV4::PersistentValue value;
PropertyAttribute attributes;
};
QVector<Property> m_properties;
class V8EXPORT Arguments {
public:
Arguments(const QV4::Value *args, int argc, const QV4::Value &thisObject, bool isConstructor,
- const Persistent<Value> &data);
+ const Handle<Value> &data);
int Length() const;
Handle<Value> operator[](int i) const;
Handle<Object> This() const;
Isolate* GetIsolate() const;
private:
- QVector<Persistent<Value> > m_args;
- Persistent<Object> m_thisObject;
+ QVector<QV4::PersistentValue> m_args;
+ QV4::PersistentValue m_thisObject;
bool m_isConstructor;
- Persistent<Value> m_data;
+ QV4::PersistentValue m_data;
};
*/
class V8EXPORT AccessorInfo {
public:
- AccessorInfo(const QV4::Value &thisObject, const Persistent<Value> &data);
+ AccessorInfo(const QV4::Value &thisObject, const Handle<Value> &data);
Isolate* GetIsolate() const;
Handle<Value> Data() const;
Handle<Object> This() const;
Handle<Object> Holder() const;
private:
- Persistent<Value> m_this;
- Persistent<Value> m_data;
+ QV4::PersistentValue m_this;
+ QV4::PersistentValue m_data;
};
friend class V4V8Function;
InvocationCallback m_callback;
NewInvocationCallback m_newCallback;
- Persistent<Value> m_data;
+ QV4::PersistentValue m_data;
Handle<ObjectTemplate> m_instanceTemplate;
Handle<ObjectTemplate> m_prototypeTemplate;
};
void MarkAsUseUserObjectComparison();
struct Accessor {
- Persistent<Value> getter;
- Persistent<Value> setter;
- Persistent<String> name;
+ QV4::PersistentValue getter;
+ QV4::PersistentValue setter;
+ QV4::PersistentValue name;
PropertyAttribute attribute;
};
NamedPropertyQuery m_namedPropertyQuery;
NamedPropertyDeleter m_namedPropertyDeleter;
NamedPropertyEnumerator m_namedPropertyEnumerator;
- Persistent<Value> m_namedPropertyData;
+ QV4::PersistentValue m_namedPropertyData;
NamedPropertyGetter m_fallbackPropertyGetter;
NamedPropertySetter m_fallbackPropertySetter;
NamedPropertyQuery m_fallbackPropertyQuery;
NamedPropertyDeleter m_fallbackPropertyDeleter;
NamedPropertyEnumerator m_fallbackPropertyEnumerator;
- Persistent<Value> m_fallbackPropertyData;
+ QV4::PersistentValue m_fallbackPropertyData;
IndexedPropertyGetter m_indexedPropertyGetter;
IndexedPropertySetter m_indexedPropertySetter;
IndexedPropertyQuery m_indexedPropertyQuery;
IndexedPropertyDeleter m_indexedPropertyDeleter;
IndexedPropertyEnumerator m_indexedPropertyEnumerator;
- Persistent<Value> m_indexedPropertyData;
+ QV4::PersistentValue m_indexedPropertyData;
bool m_useUserComparison;
private:
* are removed. It is intended to be used in the before-garbage-collection
* callback function.
*/
- static void AddImplicitReferences(Persistent<Object> parent,
- Persistent<Value>* children,
- size_t length);
+// static void AddImplicitReferences(Persistent<Object> parent,
+// Persistent<Value>* children,
+// size_t length);
};
~Context() {}
};
-template<typename T>
-void Persistent<T>::MakeWeak(void* parameters, WeakReferenceCallback callback)
-{
- Q_UNUSED(parameters);
- Q_UNUSED(callback);
-
- Q_UNIMPLEMENTED();
-}
-
-
} // namespace v8
v8::V8::SetUserObjectComparisonCallbackFunction(ObjectComparisonCallback);
QV8GCCallback::registerGcPrologueCallback();
- m_strongReferencer = qPersistentNew(v8::Object::New());
+ m_strongReferencer = QV4::Value::fromObject(m_v4Engine->newObject());
m_bindingFlagKey = QV4::Value::fromString(m_v4Engine->current, QStringLiteral("qml::binding"));
delete m_listModelData;
m_listModelData = 0;
- qPersistentDispose(m_strongReferencer);
-
m_jsonWrapper.destroy();
m_sequenceWrapper.destroy();
m_valueTypeWrapper.destroy();
}
}
-void QV8Engine::addRelationshipForGC(QObject *object, v8::Persistent<v8::Value> handle)
+void QV8Engine::addRelationshipForGC(QObject *object, const QV4::PersistentValue &handle)
{
- if (!object || handle.IsEmpty())
+ if (!object || handle.isEmpty())
return;
bool handleShouldBeStrong = false;
QV4::PersistentValue *implicitOwner = findOwnerAndStrength(object, &handleShouldBeStrong);
if (handleShouldBeStrong) {
- v8::V8::AddImplicitReferences(m_strongReferencer, &handle, 1);
+ // ### FIXME
+// v8::V8::AddImplicitReferences(m_strongReferencer, &handle, 1);
} else if (!implicitOwner->isEmpty()) {
// ### FIXME
qWarning() << "Fix object ownership";
QObject *qtObjectFromJS(const QV4::Value &value);
- void addRelationshipForGC(QObject *object, v8::Persistent<v8::Value> handle);
+ void addRelationshipForGC(QObject *object, const QV4::PersistentValue &handle);
void addRelationshipForGC(QObject *object, QObject *other);
static v8::Handle<v8::Value> getPlatform(v8::Handle<v8::String> property, const v8::AccessorInfo &info);
static ThreadData* threadData();
static void ensurePerThreadIsolate();
- v8::Persistent<v8::Object> m_strongReferencer;
+ QV4::PersistentValue m_strongReferencer;
protected:
QJSEngine* q;
Q_DISABLE_COPY(QV8Engine)
};
-// Allocate a new Persistent handle. *ALL* persistent handles in QML must be allocated
-// using this method.
-template<class T>
-v8::Persistent<T> qPersistentNew(v8::Handle<T> that)
-{
- v8::Persistent<T> rv = v8::Persistent<T>::New(that);
-#ifdef QML_GLOBAL_HANDLE_DEBUGGING
- QV8Engine::registerHandle(*rv);
-#endif
- return rv;
-}
-
-// Register a Persistent handle that was returned to you by V8 (such as by
-// v8::Context::New). This allows us to do handle tracking on these handles too.
-template<class T>
-void qPersistentRegister(v8::Persistent<T> handle)
-{
-#ifdef QML_GLOBAL_HANDLE_DEBUGGING
- QV8Engine::registerHandle(*handle);
-#else
- Q_UNUSED(handle);
-#endif
-}
-
-// Dispose and clear a persistent handle. *ALL* persistent handles in QML must be
-// disposed using this method.
-template<class T>
-void qPersistentDispose(v8::Persistent<T> &that)
-{
-#ifdef QML_GLOBAL_HANDLE_DEBUGGING
- QV8Engine::releaseHandle(*that);
-#endif
- that.Dispose();
- that.Clear();
-}
-
bool QV8Engine::isVariant(const QV4::Value &value)
{
return m_variantWrapper.isVariant(value);
v8::ThrowException(v8::Exception::Error(v8engine->toString(error)));
}
-void QV8QObjectWrapper::WeakQObjectReferenceCallback(v8::Persistent<v8::Value> handle, void *wrapper)
+void QV8QObjectWrapper::WeakQObjectReferenceCallback(QV4::PersistentValue &handle, void *wrapper)
{
- Q_ASSERT(handle->IsObject());
- v8::Handle<v8::Object> v8object = handle->ToObject();
+ Q_ASSERT(handle.value().isObject());
+ v8::Handle<v8::Object> v8object = handle.value();
QV8QObjectResource *resource = v8_resource_check<QV8QObjectResource>(v8object);
Q_ASSERT(resource);
// dispose
v8object->SetExternalResource(0);
delete resource;
- qPersistentDispose(handle);
+ handle.clear();
} else {
- handle.MakeWeak(0, WeakQObjectReferenceCallback); // revive.
+ // ### FIXME
+ // handle.MakeWeak(0, WeakQObjectReferenceCallback); // revive.
}
}
-static void WeakQObjectInstanceCallback(v8::Persistent<v8::Value> handle, void *data)
-{
- QV8QObjectInstance *instance = (QV8QObjectInstance *)data;
- instance->v8object = QV4::PersistentValue();
- qPersistentDispose(handle);
-}
-
v8::Handle<v8::Object> QQmlPropertyCache::newQObject(QObject *object, QV8Engine *engine)
{
Q_ASSERT(object);
static QV4::Value Invoke(const v8::Arguments &args);
static QPair<QObject *, int> ExtractQtMethod(QV8Engine *, v8::Handle<v8::Function>);
static QPair<QObject *, int> ExtractQtSignal(QV8Engine *, v8::Handle<v8::Object>);
- static void WeakQObjectReferenceCallback(v8::Persistent<v8::Value> handle, void *wrapper);
+ static void WeakQObjectReferenceCallback(QV4::PersistentValue &handle, void *wrapper);
QV8Engine *m_engine;
quint32 m_id;
projects / platform / upstream / qtdeclarative.git / commitdiff