437412d79b
and cid#1557869 COPY_INSTEAD_OF_MOVE cid#1557807 COPY_INSTEAD_OF_MOVE cid#1557804 COPY_INSTEAD_OF_MOVE cid#1557799 COPY_INSTEAD_OF_MOVE cid#1557781 COPY_INSTEAD_OF_MOVE cid#1557781 COPY_INSTEAD_OF_MOVE cid#1557766 COPY_INSTEAD_OF_MOVE cid#1557746 COPY_INSTEAD_OF_MOVE cid#1557737 COPY_INSTEAD_OF_MOVE Change-Id: I1866c576f525ea697c62e9e0a96890e5fdaa780f Reviewed-on: https://gerrit.libreoffice.org/c/core/+/171795 Tested-by: Jenkins Reviewed-by: Caolán McNamara <caolan.mcnamara@collabora.com>
411 lines
13 KiB
C++
411 lines
13 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
* This file is part of the LibreOffice project.
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* This file incorporates work covered by the following license notice:
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed
|
|
* with this work for additional information regarding copyright
|
|
* ownership. The ASF licenses this file to you under the Apache
|
|
* License, Version 2.0 (the "License"); you may not use this file
|
|
* except in compliance with the License. You may obtain a copy of
|
|
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
|
|
*/
|
|
|
|
|
|
#include <osl/diagnose.h>
|
|
#include <osl/interlck.h>
|
|
#include <rtl/ref.hxx>
|
|
#include <uno/dispatcher.hxx>
|
|
#include <uno/data.h>
|
|
#include <uno/lbnames.h>
|
|
#include <uno/mapping.hxx>
|
|
#include <uno/environment.hxx>
|
|
#include <typelib/typedescription.hxx>
|
|
#include <cppuhelper/exc_hlp.hxx>
|
|
#include <cppuhelper/implbase.hxx>
|
|
#include <cppuhelper/supportsservice.hxx>
|
|
#include <cppuhelper/weak.hxx>
|
|
#include <cppuhelper/weakagg.hxx>
|
|
#include <com/sun/star/lang/XServiceInfo.hpp>
|
|
#include <com/sun/star/reflection/XProxyFactory.hpp>
|
|
#include <com/sun/star/uno/RuntimeException.hpp>
|
|
#include <com/sun/star/uno/XComponentContext.hpp>
|
|
#include <utility>
|
|
|
|
|
|
using namespace ::com::sun::star;
|
|
using namespace css::uno;
|
|
|
|
|
|
namespace
|
|
{
|
|
|
|
struct FactoryImpl : public ::cppu::WeakImplHelper< lang::XServiceInfo,
|
|
reflection::XProxyFactory >
|
|
{
|
|
Environment m_uno_env;
|
|
Environment m_cpp_env;
|
|
Mapping m_uno2cpp;
|
|
Mapping m_cpp2uno;
|
|
|
|
UnoInterfaceReference binuno_queryInterface(
|
|
UnoInterfaceReference const & unoI,
|
|
typelib_InterfaceTypeDescription * pTypeDescr );
|
|
|
|
FactoryImpl();
|
|
|
|
// XServiceInfo
|
|
virtual OUString SAL_CALL getImplementationName() override;
|
|
virtual sal_Bool SAL_CALL supportsService( const OUString & rServiceName ) override;
|
|
virtual Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
|
|
|
|
// XProxyFactory
|
|
virtual Reference< XAggregation > SAL_CALL createProxy(
|
|
Reference< XInterface > const & xTarget ) override;
|
|
};
|
|
|
|
|
|
UnoInterfaceReference FactoryImpl::binuno_queryInterface(
|
|
UnoInterfaceReference const & unoI,
|
|
typelib_InterfaceTypeDescription * pTypeDescr )
|
|
{
|
|
// init queryInterface() td
|
|
static typelib_TypeDescription* s_pQITD = []() {
|
|
typelib_TypeDescription* pTXInterfaceDescr = nullptr;
|
|
TYPELIB_DANGER_GET(&pTXInterfaceDescr, cppu::UnoType<XInterface>::get().getTypeLibType());
|
|
typelib_TypeDescription* pQITD = nullptr;
|
|
typelib_typedescriptionreference_getDescription(
|
|
&pQITD, reinterpret_cast<typelib_InterfaceTypeDescription*>(pTXInterfaceDescr)
|
|
->ppAllMembers[0]);
|
|
TYPELIB_DANGER_RELEASE(pTXInterfaceDescr);
|
|
return pQITD;
|
|
}();
|
|
|
|
void * args[ 1 ];
|
|
args[ 0 ] = &reinterpret_cast< typelib_TypeDescription * >(
|
|
pTypeDescr )->pWeakRef;
|
|
uno_Any ret_val, exc_space;
|
|
uno_Any * exc = &exc_space;
|
|
|
|
unoI.dispatch( s_pQITD, &ret_val, args, &exc );
|
|
|
|
if (exc == nullptr)
|
|
{
|
|
UnoInterfaceReference ret;
|
|
if (ret_val.pType->eTypeClass == typelib_TypeClass_INTERFACE)
|
|
{
|
|
ret.set( *static_cast< uno_Interface ** >(ret_val.pData),
|
|
SAL_NO_ACQUIRE );
|
|
typelib_typedescriptionreference_release( ret_val.pType );
|
|
}
|
|
else
|
|
{
|
|
uno_any_destruct( &ret_val, nullptr );
|
|
}
|
|
return ret;
|
|
}
|
|
else
|
|
{
|
|
// exception occurred:
|
|
OSL_ENSURE(
|
|
typelib_typedescriptionreference_isAssignableFrom( cppu::UnoType<RuntimeException>::get().getTypeLibType(),
|
|
exc->pType ),
|
|
"### RuntimeException expected!" );
|
|
Any cpp_exc;
|
|
uno_type_copyAndConvertData(
|
|
&cpp_exc, exc, cppu::UnoType<decltype(cpp_exc)>::get().getTypeLibType(),
|
|
m_uno2cpp.get() );
|
|
uno_any_destruct( exc, nullptr );
|
|
::cppu::throwException( cpp_exc );
|
|
OSL_ASSERT( false ); // way of no return
|
|
return UnoInterfaceReference(); // for dummy
|
|
}
|
|
}
|
|
|
|
|
|
struct ProxyRoot : public ::cppu::OWeakAggObject
|
|
{
|
|
// XAggregation
|
|
virtual Any SAL_CALL queryAggregation( Type const & rType ) override;
|
|
|
|
ProxyRoot( ::rtl::Reference< FactoryImpl > factory,
|
|
Reference< XInterface > const & xTarget );
|
|
|
|
::rtl::Reference< FactoryImpl > m_factory;
|
|
|
|
private:
|
|
UnoInterfaceReference m_target;
|
|
};
|
|
|
|
|
|
struct binuno_Proxy : public uno_Interface
|
|
{
|
|
oslInterlockedCount m_nRefCount;
|
|
::rtl::Reference< ProxyRoot > m_root;
|
|
UnoInterfaceReference m_target;
|
|
OUString m_oid;
|
|
TypeDescription m_typeDescr;
|
|
|
|
binuno_Proxy(
|
|
::rtl::Reference< ProxyRoot > root,
|
|
UnoInterfaceReference target,
|
|
OUString oid, TypeDescription typeDescr );
|
|
};
|
|
|
|
extern "C"
|
|
{
|
|
|
|
|
|
static void binuno_proxy_free(
|
|
uno_ExtEnvironment * pEnv, void * pProxy )
|
|
{
|
|
binuno_Proxy * proxy = static_cast< binuno_Proxy * >(
|
|
static_cast< uno_Interface * >( pProxy ) );
|
|
OSL_ASSERT( proxy->m_root->m_factory->m_uno_env.get()->pExtEnv == pEnv );
|
|
delete proxy;
|
|
}
|
|
|
|
|
|
static void binuno_proxy_acquire( uno_Interface * pUnoI )
|
|
{
|
|
binuno_Proxy * that = static_cast< binuno_Proxy * >( pUnoI );
|
|
if (osl_atomic_increment( &that->m_nRefCount ) != 1)
|
|
return;
|
|
|
|
// rebirth of zombie
|
|
uno_ExtEnvironment * uno_env =
|
|
that->m_root->m_factory->m_uno_env.get()->pExtEnv;
|
|
assert(uno_env != nullptr);
|
|
(*uno_env->registerProxyInterface)(
|
|
uno_env, reinterpret_cast< void ** >( &pUnoI ), binuno_proxy_free,
|
|
that->m_oid.pData,
|
|
reinterpret_cast< typelib_InterfaceTypeDescription * >(
|
|
that->m_typeDescr.get() ) );
|
|
OSL_ASSERT( that == static_cast< binuno_Proxy * >( pUnoI ) );
|
|
}
|
|
|
|
|
|
static void binuno_proxy_release( uno_Interface * pUnoI )
|
|
{
|
|
binuno_Proxy * that = static_cast< binuno_Proxy * >( pUnoI );
|
|
if (osl_atomic_decrement( &that->m_nRefCount ) == 0)
|
|
{
|
|
uno_ExtEnvironment * uno_env =
|
|
that->m_root->m_factory->m_uno_env.get()->pExtEnv;
|
|
assert(uno_env != nullptr);
|
|
(*uno_env->revokeInterface)( uno_env, pUnoI );
|
|
}
|
|
}
|
|
|
|
|
|
static void binuno_proxy_dispatch(
|
|
uno_Interface * pUnoI, const typelib_TypeDescription * pMemberType,
|
|
void * pReturn, void * pArgs [], uno_Any ** ppException )
|
|
{
|
|
binuno_Proxy * that = static_cast< binuno_Proxy * >( pUnoI );
|
|
switch (reinterpret_cast< typelib_InterfaceMemberTypeDescription const * >(
|
|
pMemberType )->nPosition)
|
|
{
|
|
case 0: // queryInterface()
|
|
{
|
|
try
|
|
{
|
|
Type const & rType =
|
|
*static_cast< Type const * >( pArgs[ 0 ] );
|
|
Any ret( that->m_root->queryInterface( rType ) );
|
|
uno_type_copyAndConvertData(
|
|
pReturn, &ret, cppu::UnoType<decltype(ret)>::get().getTypeLibType(),
|
|
that->m_root->m_factory->m_cpp2uno.get() );
|
|
*ppException = nullptr; // no exc
|
|
}
|
|
catch (RuntimeException &)
|
|
{
|
|
Any exc( ::cppu::getCaughtException() );
|
|
uno_type_any_constructAndConvert(
|
|
*ppException, const_cast< void * >(exc.getValue()),
|
|
exc.getValueTypeRef(),
|
|
that->m_root->m_factory->m_cpp2uno.get() );
|
|
}
|
|
break;
|
|
}
|
|
case 1: // acquire()
|
|
binuno_proxy_acquire( pUnoI );
|
|
*ppException = nullptr; // no exc
|
|
break;
|
|
case 2: // release()
|
|
binuno_proxy_release( pUnoI );
|
|
*ppException = nullptr; // no exc
|
|
break;
|
|
default:
|
|
that->m_target.dispatch( pMemberType, pReturn, pArgs, ppException );
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
binuno_Proxy::binuno_Proxy(
|
|
::rtl::Reference< ProxyRoot > root,
|
|
UnoInterfaceReference target,
|
|
OUString oid, TypeDescription typeDescr )
|
|
: m_nRefCount( 1 ),
|
|
m_root(std::move( root )),
|
|
m_target(std::move( target )),
|
|
m_oid(std::move( oid )),
|
|
m_typeDescr(std::move( typeDescr ))
|
|
{
|
|
uno_Interface::acquire = binuno_proxy_acquire;
|
|
uno_Interface::release = binuno_proxy_release;
|
|
uno_Interface::pDispatcher = binuno_proxy_dispatch;
|
|
}
|
|
|
|
ProxyRoot::ProxyRoot(
|
|
::rtl::Reference< FactoryImpl > factory,
|
|
Reference< XInterface > const & xTarget )
|
|
: m_factory(std::move( factory ))
|
|
{
|
|
m_factory->m_cpp2uno.mapInterface(
|
|
reinterpret_cast< void ** >( &m_target.m_pUnoI ), xTarget.get(),
|
|
cppu::UnoType<decltype(xTarget)>::get() );
|
|
OSL_ENSURE( m_target.is(), "### mapping interface failed!" );
|
|
}
|
|
|
|
|
|
Any ProxyRoot::queryAggregation( Type const & rType )
|
|
{
|
|
Any ret( OWeakAggObject::queryAggregation( rType ) );
|
|
if (! ret.hasValue())
|
|
{
|
|
typelib_TypeDescription * pTypeDescr = nullptr;
|
|
TYPELIB_DANGER_GET( &pTypeDescr, rType.getTypeLibType() );
|
|
try
|
|
{
|
|
Reference< XInterface > xProxy;
|
|
uno_ExtEnvironment * cpp_env = m_factory->m_cpp_env.get()->pExtEnv;
|
|
assert(cpp_env != nullptr);
|
|
|
|
// mind a new delegator, calculate current root:
|
|
Reference< XInterface > xRoot(
|
|
static_cast< OWeakObject * >(this), UNO_QUERY_THROW );
|
|
OUString oid;
|
|
(*cpp_env->getObjectIdentifier)( cpp_env, &oid.pData, xRoot.get() );
|
|
OSL_ASSERT( !oid.isEmpty() );
|
|
|
|
(*cpp_env->getRegisteredInterface)(
|
|
cpp_env, reinterpret_cast< void ** >( &xProxy ),
|
|
oid.pData, reinterpret_cast<
|
|
typelib_InterfaceTypeDescription * >(pTypeDescr) );
|
|
if (! xProxy.is())
|
|
{
|
|
// perform query on target:
|
|
UnoInterfaceReference proxy_target(
|
|
m_factory->binuno_queryInterface(
|
|
m_target, reinterpret_cast<
|
|
typelib_InterfaceTypeDescription * >(pTypeDescr) ) );
|
|
if (proxy_target.is())
|
|
{
|
|
// ensure root's object entries:
|
|
UnoInterfaceReference root;
|
|
m_factory->m_cpp2uno.mapInterface(
|
|
reinterpret_cast< void ** >( &root.m_pUnoI ),
|
|
xRoot.get(), cppu::UnoType<decltype(xRoot)>::get() );
|
|
|
|
UnoInterfaceReference proxy(
|
|
// ref count initially 1:
|
|
new binuno_Proxy( this, std::move(proxy_target), oid, pTypeDescr ),
|
|
SAL_NO_ACQUIRE );
|
|
uno_ExtEnvironment * uno_env =
|
|
m_factory->m_uno_env.get()->pExtEnv;
|
|
assert(uno_env != nullptr);
|
|
(*uno_env->registerProxyInterface)(
|
|
uno_env, reinterpret_cast< void ** >( &proxy.m_pUnoI ),
|
|
binuno_proxy_free, oid.pData,
|
|
reinterpret_cast< typelib_InterfaceTypeDescription * >(
|
|
pTypeDescr ) );
|
|
|
|
m_factory->m_uno2cpp.mapInterface(
|
|
reinterpret_cast< void ** >( &xProxy ),
|
|
proxy.get(), pTypeDescr );
|
|
}
|
|
}
|
|
if (xProxy.is())
|
|
ret.setValue( &xProxy, pTypeDescr );
|
|
}
|
|
catch (...) // finally
|
|
{
|
|
TYPELIB_DANGER_RELEASE( pTypeDescr );
|
|
throw;
|
|
}
|
|
TYPELIB_DANGER_RELEASE( pTypeDescr );
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
FactoryImpl::FactoryImpl()
|
|
{
|
|
OUString uno = u"" UNO_LB_UNO ""_ustr;
|
|
OUString cpp = CPPU_CURRENT_LANGUAGE_BINDING_NAME;
|
|
|
|
uno_getEnvironment(
|
|
reinterpret_cast< uno_Environment ** >( &m_uno_env ), uno.pData, nullptr );
|
|
OSL_ENSURE( m_uno_env.is(), "### cannot get binary uno env!" );
|
|
|
|
uno_getEnvironment(
|
|
reinterpret_cast< uno_Environment ** >( &m_cpp_env ), cpp.pData, nullptr );
|
|
OSL_ENSURE( m_cpp_env.is(), "### cannot get C++ uno env!" );
|
|
|
|
uno_getMapping(
|
|
reinterpret_cast< uno_Mapping ** >( &m_uno2cpp ),
|
|
m_uno_env.get(), m_cpp_env.get(), nullptr );
|
|
OSL_ENSURE( m_uno2cpp.is(), "### cannot get bridge uno <-> C++!" );
|
|
|
|
uno_getMapping(
|
|
reinterpret_cast< uno_Mapping ** >( &m_cpp2uno ),
|
|
m_cpp_env.get(), m_uno_env.get(), nullptr );
|
|
OSL_ENSURE( m_cpp2uno.is(), "### cannot get bridge C++ <-> uno!" );
|
|
}
|
|
|
|
// XProxyFactory
|
|
|
|
Reference< XAggregation > FactoryImpl::createProxy(
|
|
Reference< XInterface > const & xTarget )
|
|
{
|
|
return new ProxyRoot( this, xTarget );
|
|
}
|
|
|
|
// XServiceInfo
|
|
|
|
OUString FactoryImpl::getImplementationName()
|
|
{
|
|
return u"com.sun.star.comp.reflection.ProxyFactory"_ustr;
|
|
}
|
|
|
|
sal_Bool FactoryImpl::supportsService( const OUString & rServiceName )
|
|
{
|
|
return cppu::supportsService(this, rServiceName);
|
|
}
|
|
|
|
Sequence< OUString > FactoryImpl::getSupportedServiceNames()
|
|
{
|
|
return { u"com.sun.star.reflection.ProxyFactory"_ustr };
|
|
}
|
|
|
|
extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
|
|
stoc_FactoryImpl_get_implementation(
|
|
css::uno::XComponentContext* , css::uno::Sequence<css::uno::Any> const&)
|
|
{
|
|
return cppu::acquire(new FactoryImpl);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|