void QQuickLoaderPrivate::disposeInitialPropertyValues()
{
if (!initialPropertyValues.IsEmpty())
qPersistentDispose(initialPropertyValues);
if (!qmlGlobalForIpv.IsEmpty())
qPersistentDispose(qmlGlobalForIpv);
}
/*
Converting from a message to an error is relatively expensive.
We don't want to do this work for transient exceptions (exceptions
that occur during startup because of the order of binding
execution, but have gone away by the time startup has finished), so we
delay conversion until it is required for displaying the error.
*/
void QQmlDelayedError::convertMessageToError(QQmlEngine *engine) const
{
if (!m_message.IsEmpty() && engine) {
v8::HandleScope handle_scope;
v8::Context::Scope context_scope(QQmlEnginePrivate::getV8Engine(engine)->context());
QQmlExpressionPrivate::exceptionToError(m_message, m_error);
qPersistentDispose(m_message);
}
}
void QV8ListWrapper::destroy()
{
qPersistentDispose(m_constructor);
}
void QQmlCompiledData::clear()
{
for (int ii = 0; ii < programs.count(); ++ii)
qPersistentDispose(programs[ii].bindings);
}
void QDeclarativePropertyCache::append(QDeclarativeEngine *engine, const QMetaObject *metaObject,
int revision,
Data::Flag propertyFlags, Data::Flag methodFlags, Data::Flag signalFlags)
{
Q_UNUSED(revision);
qPersistentDispose(constructor); // Now invalid
bool dynamicMetaObject = isDynamicMetaObject(metaObject);
allowedRevisionCache.append(0);
int methodCount = metaObject->methodCount();
// 3 to block the destroyed signal and the deleteLater() slot
int methodOffset = qMax(3, metaObject->methodOffset());
methodIndexCache.resize(methodCount - methodIndexCacheStart);
for (int ii = methodOffset; ii < methodCount; ++ii) {
QMetaMethod m = metaObject->method(ii);
if (m.access() == QMetaMethod::Private)
continue;
// Extract method name
const char *signature = m.signature();
const char *cptr = signature;
while (*cptr != '(') { Q_ASSERT(*cptr != 0); ++cptr; }
QString str = dynamicMetaObject?QString::fromUtf8(signature, cptr - signature):
QString::fromLatin1(signature, cptr - signature);
QHashedString methodName(str);
Data *data = &methodIndexCache[ii - methodIndexCacheStart];
data->lazyLoad(m);
if (data->isSignal())
data->flags |= signalFlags;
else
data->flags |= methodFlags;
if (!dynamicMetaObject)
data->flags |= Data::IsDirect;
data->metaObjectOffset = allowedRevisionCache.count() - 1;
if (Data **old = stringCache.value(methodName)) {
// We only overload methods in the same class, exactly like C++
if ((*old)->flags & Data::IsFunction && (*old)->coreIndex >= methodOffset)
data->relatedIndex = (*old)->coreIndex;
data->overrideIndexIsProperty = !bool((*old)->flags & Data::IsFunction);
data->overrideIndex = (*old)->coreIndex;
}
stringCache.insert(methodName, data);
}
int propCount = metaObject->propertyCount();
int propOffset = metaObject->propertyOffset();
propertyIndexCache.resize(propCount - propertyIndexCacheStart);
for (int ii = propOffset; ii < propCount; ++ii) {
QMetaProperty p = metaObject->property(ii);
if (!p.isScriptable())
continue;
QString str = dynamicMetaObject?QString::fromUtf8(p.name()):
QString::fromLatin1(p.name());
QHashedString propName(str);
Data *data = &propertyIndexCache[ii - propertyIndexCacheStart];
data->lazyLoad(p, engine);
data->flags |= propertyFlags;
if (!dynamicMetaObject)
data->flags |= Data::IsDirect;
data->metaObjectOffset = allowedRevisionCache.count() - 1;
if (Data **old = stringCache.value(propName)) {
data->overrideIndexIsProperty = !bool((*old)->flags & Data::IsFunction);
data->overrideIndex = (*old)->coreIndex;
}
stringCache.insert(propName, data);
}
}
// This is inherited from QDeclarativeCleanup, so it should only clear the things
// that are tied to the specific QDeclarativeEngine.
void QDeclarativePropertyCache::clear()
{
qPersistentDispose(constructor);
engine = 0;
}
QQmlBinding::~QQmlBinding()
{
qPersistentDispose(v8function);
}
void QV8ContextWrapper::destroy()
{
qPersistentDispose(m_sharedContext);
qPersistentDispose(m_urlConstructor);
qPersistentDispose(m_constructor);
}
QQmlSqlDatabaseData::~QQmlSqlDatabaseData()
{
qPersistentDispose(constructor);
qPersistentDispose(queryConstructor);
qPersistentDispose(rowsConstructor);
}
QQmlBoundSignalExpression::~QQmlBoundSignalExpression()
{
qPersistentDispose(m_v8function);
qPersistentDispose(m_v8qmlscope);
}
QV8Include::~QV8Include()
{
delete m_reply; m_reply = 0;
qPersistentDispose(m_callbackFunction);
qPersistentDispose(m_resultObject);
}
QQuickV8ParticleData::~QQuickV8ParticleData()
{
qPersistentDispose(m_v8Value);
}
QV8ParticleDataDeletable::~QV8ParticleDataDeletable()
{
qPersistentDispose(constructor);
}
void QQmlDelayedError::setMessage(v8::Handle<v8::Message> message)
{
qPersistentDispose(m_message);
m_message = qPersistentNew<v8::Message>(message);
}
