drop LazyDeletor

Change-Id: I7d2e00466f321994a46b0529d645e342f229c929
Reviewed-on: https://gerrit.libreoffice.org/61718
Tested-by: Jenkins
Reviewed-by: Caolán McNamara <caolanm@redhat.com>
Tested-by: Caolán McNamara <caolanm@redhat.com>

1 files changed, 1 insertions, 151 deletions

diff --git a/include/vcl/lazydelete.hxx b/include/vcl/lazydelete.hxx
index 89c88cbf4cc2..f7d74573de66 100644
--- a/include/vcl/lazydelete.hxx
+++ b/include/vcl/lazydelete.hxx
@@ -35,158 +35,8 @@
 
 namespace vcl
 {
-    /* Helpers for lazy object deletion
-
-    With vcl it is often necessary to delete objects (especially Windows)
-    in the right order as well as in a way ensuring that the deleted objects
-    are not still on the stack (e.g. deleting a Window in its key handler). To
-    make this easier a helper class is given here which takes care of both
-    sorting as well as lazy deletion.
-
-    The grisly details:
-    LazyDelete is a class that LazyDeletor register to. When vcl's event
-    loop (that is Application::Yield or Application::Reschedule) comes out
-    of the last level, the LazyDelete::flush is called. This will cause
-    LazyDelete to delete all registered LazyDeletor objects.
-
-    LazyDeletor<T> is a one instance object that contains a list of
-    <T> objects to be deleted in sorted order. It is derived from
-    LazyDeletorBase as to be able to register itself in LazyDelete.
-
-    The user calls the static method LazyDeletor<T>::Delete( T* ) with the
-    object to be destroyed lazy. The static method creates the LazyDeletor<T>
-    (which in turn registers itself in LazyDelete) if this is the first time
-    a T* is to be destroyed lazy. It then inserts the object. When the LazyDeletor<T>
-    gets delete it will delete the stored objects in a fashion
-    that will ensure the correct order of deletion via the specialized is_less method
-    (e.g. if a Window is a child of another Window and therefore should be destroyed
-    first it is "less" in this sense)
-
-    LazyDelete::flush will be called when the top of the nested event loop is
-    reached again and will then destroy each registered LazyDeletor<T> which
-    in turn destroys the objects needed to be destroyed lazily. After this
-    the state is as before entering the event loop.
-
-    Preconditions:
-    - The class <T> of which objects are to be destroyed needs a virtual
-    destructor or must be final, else the wrong type will be destroyed.
-    - The destructor of <T> should call LazyDeletor<T>::Undelete( this ). This
-    prevents duplicate deletion in case someone destroys the object prematurely.
-    */
-
-    class LazyDeletorBase;
-    class VCL_DLLPUBLIC LazyDelete
-    {
-        public:
-        /** flush all registered object lists
-        */
-        static void flush();
-        /** register an object list to be destroyed
-        */
-        static void addDeletor( LazyDeletorBase* pDeletor );
-    };
-
-    class VCL_DLLPUBLIC LazyDeletorBase
-    {
-        friend void LazyDelete::flush();
-        protected:
-        LazyDeletorBase();
-        virtual ~LazyDeletorBase();
-    };
-
-    class VCL_DLLPUBLIC LazyDeletor : public LazyDeletorBase
-    {
-        static LazyDeletor*     s_pOneInstance;
-
-        struct DeleteObjectEntry
-        {
-            VclPtr<vcl::Window> m_pObject;
-            bool      m_bDeleted;
-
-            DeleteObjectEntry( vcl::Window* i_pObject ) :
-                m_pObject( i_pObject ),
-                m_bDeleted( false )
-            {}
-        };
-
-        std::vector< DeleteObjectEntry >    m_aObjects;
-        typedef std::unordered_map< sal_IntPtr, unsigned int > PtrToIndexMap;
-        PtrToIndexMap                       m_aPtrToIndex;
-
-        /** strict weak ordering function to bring objects to be destroyed lazily
-        in correct order, e.g. for Window objects children before parents
-        */
-        static bool is_less( vcl::Window const * left, vcl::Window const * right );
-
-        LazyDeletor()  { LazyDelete::addDeletor( this ); }
-        virtual ~LazyDeletor() override
-        {
-            SAL_INFO("vcl.lazydelete", typeid(*this).name() << std::hex << this << " deleted");
-            if( s_pOneInstance == this ) // sanity check
-                s_pOneInstance = nullptr;
-
-            // do the actual work
-            unsigned int nCount = m_aObjects.size();
-            std::vector< VclPtr < vcl::Window > > aRealDelete;
-            aRealDelete.reserve( nCount );
-            for( unsigned int i = 0; i < nCount; i++ )
-            {
-                if( ! m_aObjects[i].m_bDeleted )
-                {
-                    aRealDelete.push_back( m_aObjects[i].m_pObject );
-                }
-            }
-            // sort the vector of objects to be destroyed
-            std::sort( aRealDelete.begin(), aRealDelete.end(), is_less );
-            nCount = aRealDelete.size();
-            for( unsigned int n = 0; n < nCount; n++ )
-            {
-                SAL_INFO("vcl.lazydelete", typeid(*this).name() << " deletes object " << aRealDelete[n] << " of type "
-                         << typeid(*aRealDelete[n]).name());
-                // check if the object to be deleted is not already destroyed
-                // as a side effect of a previous lazily destroyed object
-                if( ! m_aObjects[ m_aPtrToIndex[ reinterpret_cast<sal_IntPtr>(aRealDelete[n].get()) ] ].m_bDeleted )
-                    aRealDelete[n].disposeAndClear();
-            }
-        }
-
-        public:
-        /** mark an object for lazy deletion
-        */
-        static void Delete( vcl::Window* i_pObject )
-        {
-            if( s_pOneInstance == nullptr )
-                s_pOneInstance = new LazyDeletor();
-
-            // is this object already in the list ?
-            // if so mark it as not to be deleted; else insert it
-            PtrToIndexMap::const_iterator dup = s_pOneInstance->m_aPtrToIndex.find( reinterpret_cast<sal_IntPtr>(i_pObject) );
-            if( dup != s_pOneInstance->m_aPtrToIndex.end() )
-            {
-                s_pOneInstance->m_aObjects[ dup->second ].m_bDeleted = false;
-            }
-            else
-            {
-                s_pOneInstance->m_aPtrToIndex[ reinterpret_cast<sal_IntPtr>(i_pObject) ] = s_pOneInstance->m_aObjects.size();
-                s_pOneInstance->m_aObjects.push_back( DeleteObjectEntry( i_pObject ) );
-            }
-        }
-        /** unmark an object already marked for lazy deletion
-        */
-        static void Undelete( vcl::Window* i_pObject )
-        {
-            if( s_pOneInstance )
-            {
-                PtrToIndexMap::const_iterator it = s_pOneInstance->m_aPtrToIndex.find( reinterpret_cast<sal_IntPtr>(i_pObject) );
-                if( it != s_pOneInstance->m_aPtrToIndex.end() )
-                    s_pOneInstance->m_aObjects[ it->second ].m_bDeleted = true;
-            }
-        }
-    };
-
     /*
-    class DeleteOnDeinit matches a similar need as LazyDelete for static objects:
-    you may not access vcl objects after DeInitVCL has been called this includes their destruction
+    You may not access vcl objects after DeInitVCL has been called this includes their destruction
     therefore disallowing the existence of static vcl object like e.g. a static BitmapEx
     To work around this use DeleteOnDeinit<BitmapEx> which will allow you to have a static object container,
     that will have its contents destroyed on DeinitVCL. The single drawback is that you need to check on the