From c060e7851bd6238ad6f4bdf0997c958c561cf8cf Mon Sep 17 00:00:00 2001 From: Noel Grandin Date: Tue, 21 Feb 2023 13:59:13 +0200 Subject: [PATCH] osl::Mutex->std::mutex in BaseContainer Change-Id: I66fcebb897446a5839ebde03e8e0a91d75a5e57c Reviewed-on: https://gerrit.libreoffice.org/c/core/+/147402 Tested-by: Jenkins Reviewed-by: Noel Grandin --- filter/source/config/cache/basecontainer.cxx | 131 ++++++------------ filter/source/config/cache/basecontainer.hxx | 14 +- .../config/cache/contenthandlerfactory.cxx | 2 +- filter/source/config/cache/filterfactory.cxx | 18 +-- .../config/cache/frameloaderfactory.cxx | 2 +- filter/source/config/cache/typedetection.cxx | 79 +++++------ filter/source/config/cache/typedetection.hxx | 14 +- 7 files changed, 108 insertions(+), 152 deletions(-) diff --git a/filter/source/config/cache/basecontainer.cxx b/filter/source/config/cache/basecontainer.cxx index 0dee9d4ba25a..aa8ccd2d562a 100644 --- a/filter/source/config/cache/basecontainer.cxx +++ b/filter/source/config/cache/basecontainer.cxx @@ -33,7 +33,6 @@ namespace filter::config{ BaseContainer::BaseContainer() : m_eType() - , m_lListener (m_aMutex) { GetTheFilterCache().load(FilterCache::E_CONTAINS_STANDARD); } @@ -49,7 +48,7 @@ void BaseContainer::init(const OUString& FilterCache::EItemType eType ) { // SAFE -> - osl::MutexGuard aLock(m_aMutex); + std::unique_lock aLock(m_aMutex); m_sImplementationName = sImplementationName; m_lServiceNames = lServiceNames ; @@ -58,12 +57,9 @@ void BaseContainer::init(const OUString& } -void BaseContainer::impl_loadOnDemand() +void BaseContainer::impl_loadOnDemand(std::unique_lock& /*rGuard*/) { #ifdef LOAD_IMPLICIT - // SAFE -> - osl::MutexGuard aLock(m_aMutex); - // A generic container needs all items of a set of our cache! // Of course it can block for a while, till the cache is really filled. // Note: don't load all sets supported by the cache here! @@ -89,33 +85,26 @@ void BaseContainer::impl_loadOnDemand() } GetTheFilterCache().load(eRequiredState); - // <- SAFE #endif } -void BaseContainer::impl_initFlushMode() +void BaseContainer::impl_initFlushMode(std::unique_lock& /*rGuard*/) { - // SAFE -> - osl::MutexGuard aLock(m_aMutex); if (!m_pFlushCache) m_pFlushCache = GetTheFilterCache().clone(); if (!m_pFlushCache) throw css::uno::RuntimeException( "Can not create write copy of internal used cache on demand.", static_cast< OWeakObject* >(this)); - // <- SAFE } -FilterCache* BaseContainer::impl_getWorkingCache() const +FilterCache* BaseContainer::impl_getWorkingCache(std::unique_lock& /*rGuard*/) const { - // SAFE -> - osl::MutexGuard aLock(m_aMutex); if (m_pFlushCache) return m_pFlushCache.get(); else return &GetTheFilterCache(); - // <- SAFE } @@ -154,15 +143,15 @@ void SAL_CALL BaseContainer::insertByName(const OUString& sItem , throw css::lang::IllegalArgumentException(ex.Message, static_cast< css::container::XNameContainer* >(this), 2); } - impl_loadOnDemand(); - // SAFE -> ---------------------------------- - osl::MutexGuard aLock(m_aMutex); + std::unique_lock aLock(m_aMutex); + + impl_loadOnDemand(aLock); // create write copy of used cache on demand ... - impl_initFlushMode(); + impl_initFlushMode(aLock); - FilterCache* pCache = impl_getWorkingCache(); + FilterCache* pCache = impl_getWorkingCache(aLock); if (pCache->hasItem(m_eType, sItem)) throw css::container::ElementExistException(OUString(), static_cast< css::container::XNameContainer* >(this)); pCache->setItem(m_eType, sItem, aItem); @@ -172,15 +161,15 @@ void SAL_CALL BaseContainer::insertByName(const OUString& sItem , void SAL_CALL BaseContainer::removeByName(const OUString& sItem) { - impl_loadOnDemand(); - // SAFE -> ---------------------------------- - osl::MutexGuard aLock(m_aMutex); + std::unique_lock aLock(m_aMutex); + + impl_loadOnDemand(aLock); // create write copy of used cache on demand ... - impl_initFlushMode(); + impl_initFlushMode(aLock); - FilterCache* pCache = impl_getWorkingCache(); + FilterCache* pCache = impl_getWorkingCache(aLock); pCache->removeItem(m_eType, sItem); // throw exceptions automatically // <- SAFE ---------------------------------- } @@ -204,15 +193,15 @@ void SAL_CALL BaseContainer::replaceByName(const OUString& sItem , throw css::lang::IllegalArgumentException(ex.Message, static_cast< css::container::XNameContainer* >(this), 2); } - impl_loadOnDemand(); - // SAFE -> ---------------------------------- - osl::MutexGuard aLock(m_aMutex); + std::unique_lock aLock(m_aMutex); + + impl_loadOnDemand(aLock); // create write copy of used cache on demand ... - impl_initFlushMode(); + impl_initFlushMode(aLock); - FilterCache* pCache = impl_getWorkingCache(); + FilterCache* pCache = impl_getWorkingCache(aLock); if (!pCache->hasItem(m_eType, sItem)) throw css::container::NoSuchElementException(OUString(), static_cast< css::container::XNameContainer* >(this)); pCache->setItem(m_eType, sItem, aItem); @@ -228,14 +217,14 @@ css::uno::Any SAL_CALL BaseContainer::getByName(const OUString& sItem) css::uno::Any aValue; - impl_loadOnDemand(); - // SAFE -> - osl::MutexGuard aLock(m_aMutex); + std::unique_lock aLock(m_aMutex); + + impl_loadOnDemand(aLock); try { - FilterCache* pCache = impl_getWorkingCache(); + FilterCache* pCache = impl_getWorkingCache(aLock); aValue = pCache->getItemWithStateProps(m_eType, sItem); } catch(const css::container::NoSuchElementException&) @@ -257,14 +246,14 @@ css::uno::Sequence< OUString > SAL_CALL BaseContainer::getElementNames() { css::uno::Sequence< OUString > lNames; - impl_loadOnDemand(); - // SAFE -> - osl::MutexGuard aLock(m_aMutex); + std::unique_lock aLock(m_aMutex); + + impl_loadOnDemand(aLock); try { - FilterCache* pCache = impl_getWorkingCache(); + FilterCache* pCache = impl_getWorkingCache(aLock); std::vector lKeys = pCache->getItemNames(m_eType); lNames = comphelper::containerToSequence(lKeys); } @@ -284,14 +273,14 @@ sal_Bool SAL_CALL BaseContainer::hasByName(const OUString& sItem) { bool bHasOne = false; - impl_loadOnDemand(); - // SAFE -> - osl::MutexGuard aLock(m_aMutex); + std::unique_lock aLock(m_aMutex); + + impl_loadOnDemand(aLock); try { - FilterCache* pCache = impl_getWorkingCache(); + FilterCache* pCache = impl_getWorkingCache(aLock); bHasOne = pCache->hasItem(m_eType, sItem); } catch(const css::uno::Exception&) @@ -318,14 +307,14 @@ sal_Bool SAL_CALL BaseContainer::hasElements() { bool bHasSome = false; - impl_loadOnDemand(); - // SAFE -> - osl::MutexGuard aLock(m_aMutex); + std::unique_lock aLock(m_aMutex); + + impl_loadOnDemand(aLock); try { - FilterCache* pCache = impl_getWorkingCache(); + FilterCache* pCache = impl_getWorkingCache(aLock); bHasSome = pCache->hasItems(m_eType); } catch(const css::uno::Exception&) @@ -352,16 +341,16 @@ css::uno::Reference< css::container::XEnumeration > SAL_CALL BaseContainer::crea { std::vector lKeys; - impl_loadOnDemand(); - // SAFE -> - osl::MutexGuard aLock(m_aMutex); + std::unique_lock aLock(m_aMutex); + + impl_loadOnDemand(aLock); try { // search the key names of all items, where its properties match // the given ones in its minimum - FilterCache* pCache = impl_getWorkingCache(); + FilterCache* pCache = impl_getWorkingCache(aLock); lKeys = pCache->getMatchingItemsByProps(m_eType, o3tl::span( lProperties.getConstArray(), lProperties.getLength() )); } catch(const css::uno::Exception&) @@ -390,7 +379,7 @@ css::uno::Reference< css::container::XEnumeration > SAL_CALL BaseContainer::crea void SAL_CALL BaseContainer::flush() { // SAFE -> - osl::ClearableMutexGuard aLock(m_aMutex); + std::unique_lock aLock(m_aMutex); if (!m_pFlushCache) throw css::lang::WrappedTargetRuntimeException( @@ -423,52 +412,24 @@ void SAL_CALL BaseContainer::flush() m_pFlushCache.reset(); - aLock.clear(); - // <- SAFE - - // notify listener outside the lock! - // The used listener helper lives if we live - // and is threadsafe by itself. - // Further it's not a good idea to hold the own lock - // if an outside object is called :-) css::lang::EventObject aSource (static_cast< css::util::XFlushable* >(this)); - comphelper::OInterfaceContainerHelper2* pContainer = m_lListener.getContainer(cppu::UnoType::get()); - if (!pContainer) - return; + m_lListener.notifyEach( aLock, &css::util::XFlushListener::flushed, aSource); - comphelper::OInterfaceIteratorHelper2 pIterator(*pContainer); - while (pIterator.hasMoreElements()) - { - try - { - // ... this pointer can be interesting to find out, where will be called as listener - // Don't optimize it to a direct iterator cast :-) - css::util::XFlushListener* pListener = static_cast(pIterator.next()); - pListener->flushed(aSource); - } - catch(const css::uno::Exception&) - { - // ignore any "damaged" flush listener! - // May its remote reference is broken ... - pIterator.remove(); - } - } + // <- SAFE } void SAL_CALL BaseContainer::addFlushListener(const css::uno::Reference< css::util::XFlushListener >& xListener) { - // no locks necessary - // used helper lives if we live and is threadsafe by itself ... - m_lListener.addInterface(cppu::UnoType::get(), xListener); + std::unique_lock g(m_aMutex); + m_lListener.addInterface(g, xListener); } void SAL_CALL BaseContainer::removeFlushListener(const css::uno::Reference< css::util::XFlushListener >& xListener) { - // no locks necessary - // used helper lives if we live and is threadsafe by itself ... - m_lListener.removeInterface(cppu::UnoType::get(), xListener); + std::unique_lock g(m_aMutex); + m_lListener.removeInterface(g, xListener); } } // namespace filter::config diff --git a/filter/source/config/cache/basecontainer.hxx b/filter/source/config/cache/basecontainer.hxx index 6691c1b49380..f1f63b10bc42 100644 --- a/filter/source/config/cache/basecontainer.hxx +++ b/filter/source/config/cache/basecontainer.hxx @@ -27,7 +27,7 @@ #include #include #include -#include +#include #include #include #include @@ -49,8 +49,7 @@ namespace filter::config { present by this base class!) was full initialized inside our own ctor as first! */ -class BaseContainer : public cppu::BaseMutex - , public ::cppu::WeakImplHelper< css::lang::XServiceInfo , +class BaseContainer : public ::cppu::WeakImplHelper< css::lang::XServiceInfo , css::container::XNameContainer , // => XNameReplace => XNameAccess => XElementAccess css::container::XContainerQuery , css::util::XFlushable > @@ -59,6 +58,7 @@ class BaseContainer : public cppu::BaseMutex // member protected: + mutable std::mutex m_aMutex; /** @short the implementation name of our derived class, which we provide at the interface XServiceInfo of our class... */ @@ -90,7 +90,7 @@ class BaseContainer : public cppu::BaseMutex FilterCache::EItemType m_eType; /** @short holds all listener, which are registered at this instance. */ - comphelper::OMultiTypeInterfaceContainerHelper2 m_lListener; + comphelper::OInterfaceContainerHelper4 m_lListener; // native interface @@ -155,7 +155,7 @@ class BaseContainer : public cppu::BaseMutex /** @short check if the underlying configuration data was already loaded and do it if necessary automatically. */ - void impl_loadOnDemand(); + void impl_loadOnDemand(std::unique_lock& rGuard); /** @short it creates the global instance m_pFilterCache, which is a copy @@ -167,7 +167,7 @@ class BaseContainer : public cppu::BaseMutex @throws css::uno::RuntimeException */ - void impl_initFlushMode(); + void impl_initFlushMode(std::unique_lock& rGuard); /** @short returns a pointer to the current used cache member. @@ -188,7 +188,7 @@ class BaseContainer : public cppu::BaseMutex aLock.clear(); // after this point p can't b e guaranteed any longer! */ - FilterCache* impl_getWorkingCache() const; + FilterCache* impl_getWorkingCache(std::unique_lock& rGuard) const; // uno interface diff --git a/filter/source/config/cache/contenthandlerfactory.cxx b/filter/source/config/cache/contenthandlerfactory.cxx index 089f8db5ff62..f844362b6907 100644 --- a/filter/source/config/cache/contenthandlerfactory.cxx +++ b/filter/source/config/cache/contenthandlerfactory.cxx @@ -52,7 +52,7 @@ css::uno::Reference< css::uno::XInterface > SAL_CALL ContentHandlerFactory::crea css::uno::Reference< css::uno::XInterface > xHandler; // SAFE -> - osl::MutexGuard aLock(m_aMutex); + std::unique_lock aLock(m_aMutex); auto & cache = GetTheFilterCache(); diff --git a/filter/source/config/cache/filterfactory.cxx b/filter/source/config/cache/filterfactory.cxx index e083614c04a8..481dac67a7c3 100644 --- a/filter/source/config/cache/filterfactory.cxx +++ b/filter/source/config/cache/filterfactory.cxx @@ -77,7 +77,7 @@ css::uno::Reference< css::uno::XInterface > SAL_CALL FilterFactory::createInstan const css::uno::Sequence< css::uno::Any >& lArguments) { // SAFE -> - osl::MutexGuard aLock(m_aMutex); + std::unique_lock aLock(m_aMutex); auto & cache = GetTheFilterCache(); @@ -166,10 +166,10 @@ css::uno::Reference< css::container::XEnumeration > SAL_CALL FilterFactory::crea { // SAFE -> ---------------------- { - osl::MutexGuard aLock(m_aMutex); + std::unique_lock aLock(m_aMutex); // May be not all filters was loaded ... // But we need it now! - impl_loadOnDemand(); + impl_loadOnDemand(aLock); } // <- SAFE ---------------------- @@ -251,10 +251,10 @@ std::vector FilterFactory::impl_queryMatchByDocumentService(const Quer nEFlags = pIt->second.toInt32(); // SAFE -> ---------------------- - osl::ClearableMutexGuard aLock(m_aMutex); + std::unique_lock aLock(m_aMutex); // search suitable filters - FilterCache* pCache = impl_getWorkingCache(); + FilterCache* pCache = impl_getWorkingCache(aLock); std::vector lFilterNames = pCache->getItemNames(FilterCache::E_FILTER); std::vector lResult ; @@ -312,7 +312,7 @@ std::vector FilterFactory::impl_queryMatchByDocumentService(const Quer { continue; } } - aLock.clear(); + aLock.unlock(); // <- SAFE ---------------------- return lResult; @@ -421,10 +421,10 @@ std::vector FilterFactory::impl_getSortedFilterListForModule(const OUS css::beans::NamedValue lIProps[] { { PROPNAME_DOCUMENTSERVICE, css::uno::Any(sModule) } }; // SAFE -> ---------------------- - osl::ClearableMutexGuard aLock(m_aMutex); - FilterCache* pCache = impl_getWorkingCache(); + std::unique_lock aLock(m_aMutex); + FilterCache* pCache = impl_getWorkingCache(aLock); std::vector lOtherFilters = pCache->getMatchingItemsByProps(FilterCache::E_FILTER, lIProps); - aLock.clear(); + aLock.unlock(); // <- SAFE ---------------------- // bring "other" filters in an alphabetical order diff --git a/filter/source/config/cache/frameloaderfactory.cxx b/filter/source/config/cache/frameloaderfactory.cxx index ebe4823666ad..ee78ebd98979 100644 --- a/filter/source/config/cache/frameloaderfactory.cxx +++ b/filter/source/config/cache/frameloaderfactory.cxx @@ -50,7 +50,7 @@ css::uno::Reference< css::uno::XInterface > SAL_CALL FrameLoaderFactory::createI const css::uno::Sequence< css::uno::Any >& lArguments) { // SAFE -> - osl::MutexGuard aLock(m_aMutex); + std::unique_lock aLock(m_aMutex); auto & cache = GetTheFilterCache(); diff --git a/filter/source/config/cache/typedetection.cxx b/filter/source/config/cache/typedetection.cxx index 0aaa2ffa6c3d..ebf4f0bcb7c7 100644 --- a/filter/source/config/cache/typedetection.cxx +++ b/filter/source/config/cache/typedetection.cxx @@ -73,7 +73,7 @@ OUString SAL_CALL TypeDetection::queryTypeByURL(const OUString& sURL) OUString sType; // SAFE -> - osl::MutexGuard aLock(m_aMutex); + std::unique_lock aLock(m_aMutex); css::util::URL aURL; aURL.Complete = sURL; @@ -379,7 +379,7 @@ OUString SAL_CALL TypeDetection::queryTypeByDescriptor(css::uno::Sequence< css:: try { // SAFE -> ---------------------------------- - osl::ClearableMutexGuard aLock(m_aMutex); + std::unique_lock aLock(m_aMutex); // parse given URL to split it into e.g. main and jump marks ... sURL = stlDescriptor.getUnpackedValueOrDefault(utl::MediaDescriptor::PROP_URL, OUString()); @@ -400,14 +400,14 @@ OUString SAL_CALL TypeDetection::queryTypeByDescriptor(css::uno::Sequence< css:: { // Caller specified the filter type. Honor it. Just get the default // type for that filter, and bail out. - if (impl_validateAndSetFilterOnDescriptor(stlDescriptor, aSelectedFilter)) + if (impl_validateAndSetFilterOnDescriptor(aLock, stlDescriptor, aSelectedFilter)) return stlDescriptor[utl::MediaDescriptor::PROP_TYPENAME].get(); } FlatDetection lFlatTypes; - impl_getAllFormatTypes(aURL, stlDescriptor, lFlatTypes); + impl_getAllFormatTypes(aLock, aURL, stlDescriptor, lFlatTypes); - aLock.clear(); + aLock.unlock(); // <- SAFE ---------------------------------- // Properly prioritize all candidate types. @@ -489,7 +489,7 @@ void TypeDetection::impl_checkResultsAndAddBestFilter(utl::MediaDescriptor& rDes OUString sRealType = sType; // SAFE -> - ::osl::ResettableMutexGuard aLock(m_aMutex); + std::unique_lock aLock(m_aMutex); // Attention: For executing next lines of code, We must be sure that // all filters already loaded :-( @@ -501,13 +501,13 @@ void TypeDetection::impl_checkResultsAndAddBestFilter(utl::MediaDescriptor& rDes { PROPNAME_TYPE, uno::Any(sRealType) } }; std::vector lFilters = cache.getMatchingItemsByProps(FilterCache::E_FILTER, lIProps); - aLock.clear(); + aLock.unlock(); // <- SAFE for (auto const& filter : lFilters) { // SAFE -> - aLock.reset(); + aLock.lock(); try { CacheItem aFilter = cache.getItem(FilterCache::E_FILTER, filter); @@ -520,7 +520,7 @@ void TypeDetection::impl_checkResultsAndAddBestFilter(utl::MediaDescriptor& rDes break; } catch(const css::uno::Exception&) {} - aLock.clear(); + aLock.unlock(); // <- SAFE } @@ -547,13 +547,13 @@ void TypeDetection::impl_checkResultsAndAddBestFilter(utl::MediaDescriptor& rDes try { // SAFE -> - osl::ClearableMutexGuard aLock(m_aMutex); + std::unique_lock aLock(m_aMutex); CacheItem aType = cache.getItem(FilterCache::E_TYPE, sType); aType[PROPNAME_PREFERREDFILTER] >>= sFilter; cache.getItem(FilterCache::E_FILTER, sFilter); - aLock.clear(); + aLock.unlock(); // <- SAFE // no exception => found valid type and filter => set it on the given descriptor @@ -570,7 +570,7 @@ void TypeDetection::impl_checkResultsAndAddBestFilter(utl::MediaDescriptor& rDes try { // SAFE -> - ::osl::ResettableMutexGuard aLock(m_aMutex); + std::unique_lock aLock(m_aMutex); // Attention: For executing next lines of code, We must be sure that // all filters already loaded :-( @@ -581,7 +581,7 @@ void TypeDetection::impl_checkResultsAndAddBestFilter(utl::MediaDescriptor& rDes { PROPNAME_TYPE, uno::Any(sType) } }; std::vector lFilters = cache.getMatchingItemsByProps(FilterCache::E_FILTER, lIProps); - aLock.clear(); + aLock.unlock(); // <- SAFE for (auto const& filter : lFilters) @@ -589,7 +589,7 @@ void TypeDetection::impl_checkResultsAndAddBestFilter(utl::MediaDescriptor& rDes sFilter = filter; // SAFE -> - aLock.reset(); + aLock.lock(); try { CacheItem aFilter = cache.getItem(FilterCache::E_FILTER, sFilter); @@ -601,7 +601,7 @@ void TypeDetection::impl_checkResultsAndAddBestFilter(utl::MediaDescriptor& rDes } catch(const css::uno::Exception&) { continue; } - aLock.clear(); + aLock.unlock(); // <- SAFE sFilter.clear(); @@ -620,6 +620,7 @@ void TypeDetection::impl_checkResultsAndAddBestFilter(utl::MediaDescriptor& rDes bool TypeDetection::impl_getPreselectionForType( + std::unique_lock& /*rGuard*/, const OUString& sPreSelType, const util::URL& aParsedURL, FlatDetection& rFlatTypes, bool bDocService) { // Can be used to suppress execution of some parts of this method @@ -641,10 +642,7 @@ bool TypeDetection::impl_getPreselectionForType( CacheItem aType; try { - // SAFE -> -------------------------- - osl::MutexGuard aLock(m_aMutex); aType = GetTheFilterCache().getItem(FilterCache::E_TYPE, sType); - // <- SAFE -------------------------- } catch(const css::container::NoSuchElementException&) { @@ -721,15 +719,13 @@ bool TypeDetection::impl_getPreselectionForType( } void TypeDetection::impl_getPreselectionForDocumentService( + std::unique_lock& rGuard, const OUString& sPreSelDocumentService, const util::URL& aParsedURL, FlatDetection& rFlatTypes) { // get all filters, which match to this doc service std::vector lFilters; try { - // SAFE -> -------------------------- - osl::MutexGuard aLock(m_aMutex); - // Attention: For executing next lines of code, We must be sure that // all filters already loaded :-( // That can disturb our "load on demand feature". But we have no other chance! @@ -739,7 +735,6 @@ void TypeDetection::impl_getPreselectionForDocumentService( css::beans::NamedValue lIProps[] { { PROPNAME_DOCUMENTSERVICE, css::uno::Any(sPreSelDocumentService) } }; lFilters = cache.getMatchingItemsByProps(FilterCache::E_FILTER, lIProps); - // <- SAFE -------------------------- } catch (const css::container::NoSuchElementException&) { @@ -753,20 +748,19 @@ void TypeDetection::impl_getPreselectionForDocumentService( // is an easier job than removing them .-) for (auto const& filter : lFilters) { - OUString aType = impl_getTypeFromFilter(filter); + OUString aType = impl_getTypeFromFilter(rGuard, filter); if (aType.isEmpty()) continue; - impl_getPreselectionForType(aType, aParsedURL, rFlatTypes, true); + impl_getPreselectionForType(rGuard, aType, aParsedURL, rFlatTypes, true); } } -OUString TypeDetection::impl_getTypeFromFilter(const OUString& rFilterName) +OUString TypeDetection::impl_getTypeFromFilter(std::unique_lock& /*rGuard*/, const OUString& rFilterName) { CacheItem aFilter; try { - osl::MutexGuard aLock(m_aMutex); aFilter = GetTheFilterCache().getItem(FilterCache::E_FILTER, rFilterName); } catch (const container::NoSuchElementException&) @@ -780,6 +774,7 @@ OUString TypeDetection::impl_getTypeFromFilter(const OUString& rFilterName) } void TypeDetection::impl_getAllFormatTypes( + std::unique_lock& rGuard, const util::URL& aParsedURL, utl::MediaDescriptor const & rDescriptor, FlatDetection& rFlatTypes) { rFlatTypes.clear(); @@ -788,7 +783,6 @@ void TypeDetection::impl_getAllFormatTypes( std::vector aFilterNames; try { - osl::MutexGuard aLock(m_aMutex); auto & cache = GetTheFilterCache(); cache.load(FilterCache::E_CONTAINS_FILTERS); aFilterNames = cache.getItemNames(FilterCache::E_FILTER); @@ -801,7 +795,7 @@ void TypeDetection::impl_getAllFormatTypes( // Retrieve the default type for each of these filters, and store them. for (auto const& filterName : aFilterNames) { - OUString aType = impl_getTypeFromFilter(filterName); + OUString aType = impl_getTypeFromFilter(rGuard, filterName); if (aType.isEmpty()) continue; @@ -844,12 +838,12 @@ void TypeDetection::impl_getAllFormatTypes( // Mark pre-selected type (if any) to have it prioritized. OUString sSelectedType = rDescriptor.getUnpackedValueOrDefault(utl::MediaDescriptor::PROP_TYPENAME, OUString()); if (!sSelectedType.isEmpty()) - impl_getPreselectionForType(sSelectedType, aParsedURL, rFlatTypes, false); + impl_getPreselectionForType(rGuard, sSelectedType, aParsedURL, rFlatTypes, false); // Mark all types preferred by the current document service, to have it prioritized. OUString sSelectedDoc = rDescriptor.getUnpackedValueOrDefault(utl::MediaDescriptor::PROP_DOCUMENTSERVICE, OUString()); if (!sSelectedDoc.isEmpty()) - impl_getPreselectionForDocumentService(sSelectedDoc, aParsedURL, rFlatTypes); + impl_getPreselectionForDocumentService(rGuard, sSelectedDoc, aParsedURL, rFlatTypes); } @@ -898,9 +892,9 @@ OUString TypeDetection::impl_detectTypeFlatAndDeep( utl::MediaDescriptor& r try { // SAFE -> ---------------------------------- - osl::ClearableMutexGuard aLock(m_aMutex); + std::unique_lock aLock(m_aMutex); CacheItem aType = GetTheFilterCache().getItem(FilterCache::E_TYPE, sFlatType); - aLock.clear(); + aLock.unlock(); OUString sDetectService; aType[PROPNAME_DETECTSERVICE] >>= sDetectService; @@ -976,7 +970,7 @@ OUString TypeDetection::impl_askDetectService(const OUString& sDet // SAFE -> { - osl::MutexGuard aLock(m_aMutex); + std::unique_lock aLock(m_aMutex); xContext = m_xContext; } // <- SAFE @@ -1090,9 +1084,11 @@ OUString TypeDetection::impl_askUserForTypeAndFilterIfAllowed(utl::MediaDescript // too and no ambiguous filter registration disturb us .-) OUString sFilter = aRequest.getFilter(); - if (!impl_validateAndSetFilterOnDescriptor(rDescriptor, sFilter)) - return OUString(); - + { + std::unique_lock aLock(m_aMutex); + if (!impl_validateAndSetFilterOnDescriptor(aLock, rDescriptor, sFilter)) + return OUString(); + } OUString sType; rDescriptor[utl::MediaDescriptor::PROP_TYPENAME] >>= sType; return sType; @@ -1149,7 +1145,7 @@ bool TypeDetection::impl_validateAndSetTypeOnDescriptor( utl::MediaDescript { // SAFE -> { - osl::MutexGuard aLock(m_aMutex); + std::unique_lock aLock(m_aMutex); if (GetTheFilterCache().hasItem(FilterCache::E_TYPE, sType)) { rDescriptor[utl::MediaDescriptor::PROP_TYPENAME] <<= sType; @@ -1164,22 +1160,17 @@ bool TypeDetection::impl_validateAndSetTypeOnDescriptor( utl::MediaDescript } -bool TypeDetection::impl_validateAndSetFilterOnDescriptor( utl::MediaDescriptor& rDescriptor, +bool TypeDetection::impl_validateAndSetFilterOnDescriptor( std::unique_lock& /*rGuard*/, + utl::MediaDescriptor& rDescriptor, const OUString& sFilter ) { try { - // SAFE -> - osl::ClearableMutexGuard aLock(m_aMutex); - auto & cache = GetTheFilterCache(); CacheItem aFilter = cache.getItem(FilterCache::E_FILTER, sFilter); OUString sType; aFilter[PROPNAME_TYPE] >>= sType; - aLock.clear(); - // <- SAFE - // found valid type and filter => set it on the given descriptor rDescriptor[utl::MediaDescriptor::PROP_TYPENAME ] <<= sType ; rDescriptor[utl::MediaDescriptor::PROP_FILTERNAME] <<= sFilter; diff --git a/filter/source/config/cache/typedetection.hxx b/filter/source/config/cache/typedetection.hxx index 11441039234c..d645a3aa9c09 100644 --- a/filter/source/config/cache/typedetection.hxx +++ b/filter/source/config/cache/typedetection.hxx @@ -70,18 +70,21 @@ public: private: - bool impl_getPreselectionForType( + static bool impl_getPreselectionForType( + std::unique_lock& rGuard, const OUString& sPreSelType, const css::util::URL& aParsedURL, FlatDetection& rFlatTypes, bool bDocService); - void impl_getPreselectionForDocumentService( + static void impl_getPreselectionForDocumentService( + std::unique_lock& rGuard, const OUString& sPreSelDocumentService, const css::util::URL& aParsedURL, FlatDetection& rFlatTypes); - OUString impl_getTypeFromFilter(const OUString& rFilterName); + static OUString impl_getTypeFromFilter(std::unique_lock& rGuard, const OUString& rFilterName); /** * Get all format types that we handle. */ - void impl_getAllFormatTypes( + static void impl_getAllFormatTypes( + std::unique_lock& rGuard, const css::util::URL& aParsedURL, utl::MediaDescriptor const & rDescriptor, FlatDetection& rFlatTypes); @@ -251,7 +254,8 @@ private: @return TRUE the specified type and its registrations was valid(!) and could be set on the descriptor. */ - bool impl_validateAndSetFilterOnDescriptor( utl::MediaDescriptor& rDescriptor, + static bool impl_validateAndSetFilterOnDescriptor( std::unique_lock& rGuard, + utl::MediaDescriptor& rDescriptor, const OUString& sFilter );