From: Lars Knoll <lars.knoll@digia.com>
Date: Wed, 8 May 2013 13:04:25 +0000 (+0200)
Subject: Remove the remaining traces of v8::persistent
X-Git-Tag: upstream/5.2.1~669^2~510
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=ae2e35e3d87edd011f77edfc24497bb570bc3097;p=platform%2Fupstream%2Fqtdeclarative.git

Remove the remaining traces of v8::persistent

Change-Id: Id542914c64558c1eba30a300cb10606fa499e594
Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
---

diff --git a/src/qml/qml/qqmlvmemetaobject.cpp b/src/qml/qml/qqmlvmemetaobject.cpp
index 69a7b1a..70fcb1b 100644
--- a/src/qml/qml/qqmlvmemetaobject.cpp
+++ b/src/qml/qml/qqmlvmemetaobject.cpp
@@ -1238,11 +1238,12 @@ void QQmlVMEMetaObject::allocateVarPropertiesArray()
    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();
 }
 
diff --git a/src/qml/qml/qqmlvmemetaobject_p.h b/src/qml/qml/qqmlvmemetaobject_p.h
index bf812d5..4bc4643 100644
--- a/src/qml/qml/qqmlvmemetaobject_p.h
+++ b/src/qml/qml/qqmlvmemetaobject_p.h
@@ -208,7 +208,7 @@ public:
     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();
diff --git a/src/qml/qml/v4/qv4v8.cpp b/src/qml/qml/v4/qv4v8.cpp
index c7b0fe1..b1c9c0b 100644
--- a/src/qml/qml/v4/qv4v8.cpp
+++ b/src/qml/qml/v4/qv4v8.cpp
@@ -101,16 +101,16 @@ quint64 qv8_get_value(const QV4::Value &v)
 
 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;
@@ -118,10 +118,10 @@ struct V8AccessorGetter: FunctionObject {
     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);
@@ -137,16 +137,16 @@ DEFINE_MANAGED_VTABLE(V8AccessorGetter);
 
 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;
@@ -156,9 +156,9 @@ struct V8AccessorSetter: FunctionObject {
         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);
@@ -359,25 +359,25 @@ int StackFrame::GetColumn() const
 
 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();
 }
 
 
@@ -1318,8 +1318,8 @@ void *External::Value() const
 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;
 }
@@ -1330,13 +1330,13 @@ void Template::Set(const char *name, Handle<Value> value)
 }
 
 
-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
@@ -1346,23 +1346,23 @@ 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
@@ -1372,7 +1372,7 @@ bool Arguments::IsConstructCall() const
 
 Handle<Value> Arguments::Data() const
 {
-    return m_data;
+    return m_data.value();
 }
 
 Isolate *Arguments::GetIsolate() const
@@ -1381,10 +1381,10 @@ 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
@@ -1394,18 +1394,18 @@ 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>
@@ -1416,20 +1416,20 @@ public:
         : 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)
@@ -1439,28 +1439,28 @@ public:
             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;
@@ -1633,8 +1633,8 @@ struct V4V8Function : public V4V8Object<QV4::FunctionObject>
         : 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:
@@ -1643,7 +1643,7 @@ 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);
@@ -1671,7 +1671,7 @@ protected:
     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);
@@ -1705,7 +1705,7 @@ protected:
 
     }
 
-    Persistent<FunctionTemplate> m_functionTemplate;
+    QExplicitlySharedDataPointer<FunctionTemplate> m_functionTemplate;
 };
 
 DEFINE_MANAGED_VTABLE(V4V8Function);
@@ -1716,7 +1716,7 @@ FunctionTemplate::FunctionTemplate(InvocationCallback callback, Handle<Value> da
 {
     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)
@@ -1725,7 +1725,7 @@ FunctionTemplate::FunctionTemplate(NewInvocationCallback callback, Handle<Value>
 {
     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)
@@ -1787,14 +1787,14 @@ void ObjectTemplate::SetAccessor(Handle<String> name, AccessorGetter getter, Acc
     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;
 }
 
@@ -1805,7 +1805,7 @@ void ObjectTemplate::SetNamedPropertyHandler(NamedPropertyGetter getter, NamedPr
     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)
@@ -1815,7 +1815,7 @@ void ObjectTemplate::SetFallbackPropertyHandler(NamedPropertyGetter getter, Name
     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)
@@ -1825,7 +1825,7 @@ void ObjectTemplate::SetIndexedPropertyHandler(IndexedPropertyGetter getter, Ind
     m_indexedPropertyQuery = query;
     m_indexedPropertyDeleter = deleter;
     m_indexedPropertyEnumerator = enumerator;
-    m_indexedPropertyData = Persistent<Value>::New(data);
+    m_indexedPropertyData = data->v4Value();
 }
 
 int ObjectTemplate::InternalFieldCount()
@@ -1984,12 +1984,12 @@ void V8::RemoveGCPrologueCallback(GCPrologueCallback)
     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()
diff --git a/src/qml/qml/v4/qv4v8_p.h b/src/qml/qml/v4/qv4v8_p.h
index d2bbedd..45b6ca5 100644
--- a/src/qml/qml/v4/qv4v8_p.h
+++ b/src/qml/qml/v4/qv4v8_p.h
@@ -80,6 +80,7 @@
 
 #include "qv4global_p.h"
 #include "qv4string_p.h"
+#include "qv4value_p.h"
 #include <QStack>
 #include <QSharedData>
 
@@ -124,7 +125,6 @@ class ImplementationUtilities;
 class Signature;
 class AccessorSignature;
 template <class T> struct Handle;
-template <class T> class Persistent;
 class FunctionTemplate;
 class ObjectTemplate;
 class Data;
@@ -149,8 +149,8 @@ V8EXPORT void gcUnprotect(void *memoryManager, void *handle);
  * \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 ---
@@ -412,130 +412,6 @@ struct Handle {
     };
 };
 
-
-/**
- * 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 ---
 
 
@@ -815,8 +691,8 @@ private:
   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)
@@ -1601,8 +1477,8 @@ class V8EXPORT Template : public Data {
   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;
@@ -1619,7 +1495,7 @@ DEFINE_REFCOUNTED_HANDLE_OPERATIONS(Template)
 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;
@@ -1630,10 +1506,10 @@ class V8EXPORT Arguments {
   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;
 };
 
 
@@ -1643,14 +1519,14 @@ private:
  */
 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;
 };
 
 
@@ -1855,7 +1731,7 @@ private:
   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;
 };
@@ -1991,9 +1867,9 @@ class V8EXPORT ObjectTemplate : public Template {
   void MarkAsUseUserObjectComparison();
 
   struct Accessor {
-      Persistent<Value> getter;
-      Persistent<Value> setter;
-      Persistent<String> name;
+      QV4::PersistentValue getter;
+      QV4::PersistentValue setter;
+      QV4::PersistentValue name;
       PropertyAttribute attribute;
   };
 
@@ -2004,21 +1880,21 @@ class V8EXPORT ObjectTemplate : public Template {
   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:
@@ -2148,9 +2024,9 @@ class V8EXPORT V8 {
    * 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);
 
 };
 
@@ -2237,16 +2113,6 @@ private:
   ~Context() {}
 };
 
-template<typename T>
-void Persistent<T>::MakeWeak(void* parameters, WeakReferenceCallback callback)
-{
-    Q_UNUSED(parameters);
-    Q_UNUSED(callback);
-
-    Q_UNIMPLEMENTED();
-}
-
-
 
 }  // namespace v8
 
diff --git a/src/qml/qml/v8/qv8engine.cpp b/src/qml/qml/v8/qv8engine.cpp
index 6f699d0..650d982 100644
--- a/src/qml/qml/v8/qv8engine.cpp
+++ b/src/qml/qml/v8/qv8engine.cpp
@@ -149,7 +149,7 @@ QV8Engine::QV8Engine(QJSEngine* qq)
 
     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"));
 
@@ -175,8 +175,6 @@ QV8Engine::~QV8Engine()
     delete m_listModelData;
     m_listModelData = 0;
 
-    qPersistentDispose(m_strongReferencer);
-
     m_jsonWrapper.destroy();
     m_sequenceWrapper.destroy();
     m_valueTypeWrapper.destroy();
@@ -801,15 +799,16 @@ QV4::PersistentValue *QV8Engine::findOwnerAndStrength(QObject *object, bool *sho
     }
 }
 
-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";
diff --git a/src/qml/qml/v8/qv8engine_p.h b/src/qml/qml/v8/qv8engine_p.h
index b0dff7e..077c784 100644
--- a/src/qml/qml/v8/qv8engine_p.h
+++ b/src/qml/qml/v8/qv8engine_p.h
@@ -408,7 +408,7 @@ public:
 
     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);
@@ -428,7 +428,7 @@ public:
     static ThreadData* threadData();
     static void ensurePerThreadIsolate();
 
-    v8::Persistent<v8::Object> m_strongReferencer;
+    QV4::PersistentValue m_strongReferencer;
 
 protected:
     QJSEngine* q;
@@ -478,42 +478,6 @@ private:
     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);
diff --git a/src/qml/qml/v8/qv8qobjectwrapper.cpp b/src/qml/qml/v8/qv8qobjectwrapper.cpp
index 6f5e654..6025289 100644
--- a/src/qml/qml/v8/qv8qobjectwrapper.cpp
+++ b/src/qml/qml/v8/qv8qobjectwrapper.cpp
@@ -925,10 +925,10 @@ static void FastValueSetterReadOnly(v8::Handle<v8::String> property, v8::Handle<
     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);
 
@@ -937,19 +937,13 @@ void QV8QObjectWrapper::WeakQObjectReferenceCallback(v8::Persistent<v8::Value> h
         // 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);
diff --git a/src/qml/qml/v8/qv8qobjectwrapper_p.h b/src/qml/qml/v8/qv8qobjectwrapper_p.h
index a24ca2b..f1f09dd 100644
--- a/src/qml/qml/v8/qv8qobjectwrapper_p.h
+++ b/src/qml/qml/v8/qv8qobjectwrapper_p.h
@@ -139,7 +139,7 @@ private:
     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;