drop document_io_logring.txt and use global logging

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

5 files changed, 263 insertions, 562 deletions

diff --git a/package/inc/pch/precompiled_xstor.hxx b/package/inc/pch/precompiled_xstor.hxx
index 941d290cbffa..6976db7f1b77 100644
--- a/package/inc/pch/precompiled_xstor.hxx
+++ b/package/inc/pch/precompiled_xstor.hxx
@@ -64,7 +64,6 @@
 #include <com/sun/star/lang/XSingleComponentFactory.hpp>
 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
 #include <com/sun/star/lang/XUnoTunnel.hpp>
-#include <com/sun/star/logging/DocumentIOLogRing.hpp>
 #include <com/sun/star/registry/XRegistryKey.hpp>
 #include <com/sun/star/ucb/SimpleFileAccess.hpp>
 #include <com/sun/star/uno/Any.h>
diff --git a/package/source/xstor/owriteablestream.cxx b/package/source/xstor/owriteablestream.cxx
index a2c37e1ade42..725cf810d877 100644
--- a/package/source/xstor/owriteablestream.cxx
+++ b/package/source/xstor/owriteablestream.cxx
@@ -26,7 +26,6 @@
 #include <com/sun/star/lang/DisposedException.hpp>
 #include <com/sun/star/lang/XUnoTunnel.hpp>
 #include <com/sun/star/lang/XTypeProvider.hpp>
-#include <com/sun/star/logging/DocumentIOLogRing.hpp>
 #include <com/sun/star/io/NotConnectedException.hpp>
 #include <com/sun/star/io/TempFile.hpp>
 #include <com/sun/star/io/XInputStream.hpp>
@@ -333,25 +332,6 @@ void OWriteStream_Impl::CleanCacheStream()
     }
 }
 
-void OWriteStream_Impl::AddLog( const OUString& aMessage )
-{
-    if ( !m_xLogRing.is() )
-    {
-        try
-        {
-            uno::Reference< uno::XComponentContext > xContext( ::comphelper::getProcessComponentContext() );
-            m_xLogRing = logging::DocumentIOLogRing::get(xContext);
-        }
-        catch( const uno::Exception& )
-        {
-            // No log
-        }
-    }
-
-    if ( m_xLogRing.is() )
-        m_xLogRing->logString( aMessage );
-}
-
 void OWriteStream_Impl::InsertIntoPackageFolder( const OUString& aName,
                                                   const uno::Reference< container::XNameContainer >& xParentPackageFolder )
 {
@@ -489,8 +469,7 @@ void OWriteStream_Impl::DisposeWrappers()
         }
         catch ( const uno::RuntimeException& rRuntimeException )
         {
-            AddLog( rRuntimeException.Message );
-            AddLog( "Quiet exception" );
+            SAL_INFO("package.xstor", "Quiet exception: " << rRuntimeException.Message);
         }
 
         m_pAntiImpl = nullptr;
@@ -538,19 +517,15 @@ OUString const & OWriteStream_Impl::GetFilledTempFileIfNo( const uno::Reference<
         }
         catch( const packages::WrongPasswordException& rWrongPasswordException )
         {
-            AddLog( rWrongPasswordException.Message );
-            AddLog( "Rethrow" );
-
+            SAL_INFO("package.xstor", "Rethrow: " << rWrongPasswordException.Message);
             KillFile( aTempURL, comphelper::getProcessComponentContext() );
             throw;
         }
         catch( const uno::Exception& rException )
         {
-            AddLog( rException.Message );
-            AddLog( "Rethrow" );
-
+            SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
             KillFile( aTempURL, comphelper::getProcessComponentContext() );
-        throw;
+            throw;
         }
 
         if ( !aTempURL.isEmpty() )
@@ -661,8 +636,7 @@ uno::Reference< io::XStream > OWriteStream_Impl::GetTempFileAsStream()
             }
             catch( const uno::Exception& rException )
             {
-                AddLog( rException.Message );
-                AddLog( "Quiet exception" );
+                SAL_INFO("package.xstor", "Quiet exception: " << rException.Message);
             }
         }
     }
@@ -699,8 +673,7 @@ uno::Reference< io::XInputStream > OWriteStream_Impl::GetTempFileAsInputStream()
             }
             catch( const uno::Exception& rException )
             {
-                AddLog( rException.Message );
-                AddLog( "Quiet exception" );
+                SAL_INFO("package.xstor", "Quiet exception: " << rException.Message);
             }
         }
     }
@@ -1038,8 +1011,7 @@ void OWriteStream_Impl::ReadRelInfoIfNecessary()
         }
         catch( const uno::Exception& rException )
         {
-            AddLog( rException.Message );
-            AddLog( "Quiet exception" );
+            SAL_INFO("package.xstor", "Quiet exception: " << rException.Message);
 
             m_nRelInfoStatus = RELINFO_BROKEN;
             m_bOrigRelInfoBroken = true;
@@ -1104,9 +1076,7 @@ uno::Sequence< beans::PropertyValue > OWriteStream_Impl::ReadPackageStreamProper
         }
         catch( const uno::Exception& rException )
         {
-            AddLog( rException.Message );
-            AddLog( "Quiet exception" );
-
+            SAL_INFO("package.xstor", "Quiet exception: " << rException.Message);
             SAL_WARN( "package.xstor", "A property can't be retrieved!" );
         }
     }
@@ -1213,15 +1183,12 @@ uno::Reference< io::XStream > OWriteStream_Impl::GetStream( sal_Int32 nStreamMod
         catch( const packages::WrongPasswordException& rWrongPasswordException )
         {
             SetEncryptionKeyProperty_Impl( xPropertySet, uno::Sequence< beans::NamedValue >() );
-            AddLog( rWrongPasswordException.Message );
-            AddLog( "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << rWrongPasswordException.Message);
             throw;
         }
         catch ( const uno::Exception& rException )
         {
-            AddLog( rException.Message );
-            AddLog( "Quiet exception" );
-
+            SAL_INFO("package.xstor", "Quiet exception: " << rException.Message);
             SAL_WARN( "package.xstor", "Can't write encryption related properties!" );
             SetEncryptionKeyProperty_Impl( xPropertySet, uno::Sequence< beans::NamedValue >() );
             throw io::IOException(); // TODO:
@@ -1253,9 +1220,7 @@ uno::Reference< io::XStream > OWriteStream_Impl::GetStream( sal_Int32 nStreamMod
         }
         catch( const packages::NoEncryptionException& rNoEncryptionException )
         {
-            AddLog( rNoEncryptionException.Message );
-            AddLog( "Rethrow" );
-
+            SAL_INFO("package.xstor", "Rethrow: " << rNoEncryptionException.Message);
             throw packages::WrongPasswordException();
         }
 
@@ -1476,9 +1441,7 @@ void OWriteStream_Impl::GetCopyOfLastCommit( uno::Reference< io::XStream >& xTar
         }
         catch( const packages::NoEncryptionException& rNoEncryptionException )
         {
-            AddLog( rNoEncryptionException.Message );
-            AddLog( "No Element" );
-
+            SAL_INFO("package.xstor", "No Element: " << rNoEncryptionException.Message);
             throw packages::WrongPasswordException();
         }
 
@@ -1547,8 +1510,7 @@ void OWriteStream_Impl::GetCopyOfLastCommit( uno::Reference< io::XStream >& xTar
         {
             SAL_WARN( "package.xstor", "Can't open encrypted stream!" );
             SetEncryptionKeyProperty_Impl( xPropertySet, uno::Sequence< beans::NamedValue >() );
-            AddLog( rException.Message );
-            AddLog( "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
             throw;
         }
 
@@ -1714,8 +1676,7 @@ OWriteStream::~OWriteStream()
         }
         catch( const uno::RuntimeException& rRuntimeException )
         {
-            m_pImpl->AddLog( rRuntimeException.Message );
-            m_pImpl->AddLog( "Quiet exception" );
+            SAL_INFO("package.xstor", "Quiet exception: " << rRuntimeException.Message);
         }
     }
 }
@@ -1798,9 +1759,7 @@ void OWriteStream::CopyToStreamInternally_Impl( const uno::Reference< io::XStrea
     }
     catch ( const uno::Exception& rException )
     {
-        m_pImpl->AddLog( rException.Message );
-        m_pImpl->AddLog( "Quiet exception" );
-
+        SAL_INFO("package.xstor", "Quiet exception: " << rException.Message);
         // TODO: set the stream in invalid state or dispose
         SAL_WARN( "package.xstor", "The stream become invalid during copiing!" );
         throw uno::RuntimeException();
@@ -2406,9 +2365,7 @@ void SAL_CALL OWriteStream::dispose()
             }
             catch( const uno::Exception& rException )
             {
-                m_pImpl->AddLog( rException.Message );
-                m_pImpl->AddLog( "Rethrow" );
-
+                SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
                 uno::Any aCaught( ::cppu::getCaughtException() );
                 throw lang::WrappedTargetRuntimeException("Can not commit/revert the storage!",
                                                 static_cast< OWeakObject* >( this ),
@@ -2532,15 +2489,12 @@ sal_Bool SAL_CALL OWriteStream::hasEncryptionData()
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-        m_pImpl->AddLog( rException.Message );
-        m_pImpl->AddLog( "Rethrow" );
-
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
         uno::Any aCaught( ::cppu::getCaughtException() );
         throw lang::WrappedTargetRuntimeException( "Problems on hasEncryptionData!",
                                   static_cast< ::cppu::OWeakObject* >( this ),
@@ -2570,8 +2524,7 @@ sal_Bool SAL_CALL OWriteStream::hasByID(  const OUString& sID )
     }
     catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( rNoSuchElementException.Message );
-        m_pImpl->AddLog( "No Element" );
+        SAL_INFO("package.xstor", "No Element: " << rNoSuchElementException.Message);
     }
 
     return false;
@@ -3215,27 +3168,22 @@ void SAL_CALL OWriteStream::commit()
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-        m_pImpl->AddLog( rException.Message );
-        m_pImpl->AddLog( "Rethrow" );
-
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
         uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( "Problems on commit!",
                                   static_cast< ::cppu::OWeakObject* >( this ),
@@ -3275,27 +3223,22 @@ void SAL_CALL OWriteStream::revert()
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-        m_pImpl->AddLog( rException.Message );
-        m_pImpl->AddLog( "Rethrow" );
-
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
         uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( "Problems on revert!",
                                   static_cast< ::cppu::OWeakObject* >( this ),
diff --git a/package/source/xstor/owriteablestream.hxx b/package/source/xstor/owriteablestream.hxx
index fab951b32c69..a7cd759b6a72 100644
--- a/package/source/xstor/owriteablestream.hxx
+++ b/package/source/xstor/owriteablestream.hxx
@@ -38,7 +38,6 @@
 #include <com/sun/star/embed/XTransactionBroadcaster.hpp>
 #include <com/sun/star/container/XNameContainer.hpp>
 #include <com/sun/star/beans/StringPair.hpp>
-#include <com/sun/star/logging/XSimpleLogRing.hpp>
 
 #include <cppuhelper/weak.hxx>
 #include <cppuhelper/interfacecontainer.h>
@@ -91,7 +90,6 @@ struct OWriteStream_Impl : public MutexHolder
     bool                        m_bFlushed;      // sending the streams is coordinated by the root storage of the package
 
     css::uno::Reference< css::packages::XDataSinkEncrSupport > m_xPackageStream;
-    css::uno::Reference< css::logging::XSimpleLogRing >  m_xLogRing;
 
     css::uno::Reference< css::uno::XComponentContext > m_xContext;
 
@@ -156,8 +154,6 @@ public:
 
     void CleanCacheStream();
 
-    void AddLog( const OUString& aMessage );
-
     bool UsesCommonEncryption_Impl() { return m_bUseCommonEncryption; }
     bool HasTempFile_Impl() const { return ( m_aTempURL.getLength() != 0 ); }
     bool IsTransacted();
diff --git a/package/source/xstor/xstorage.cxx b/package/source/xstor/xstorage.cxx
index aa3007439d88..b451a625ecac 100644
--- a/package/source/xstor/xstorage.cxx
+++ b/package/source/xstor/xstorage.cxx
@@ -31,7 +31,6 @@
 #include <com/sun/star/packages/WrongPasswordException.hpp>
 #include <com/sun/star/ucb/XProgressHandler.hpp>
 #include <com/sun/star/io/TempFile.hpp>
-#include <com/sun/star/logging/DocumentIOLogRing.hpp>
 #include <com/sun/star/ucb/SimpleFileAccess.hpp>
 #include <com/sun/star/container/XHierarchicalNameAccess.hpp>
 #include <com/sun/star/container/XEnumerationAccess.hpp>
@@ -296,8 +295,7 @@ OStorage_Impl::~OStorage_Impl()
             }
             catch ( const uno::Exception& rException )
             {
-                AddLog( rException.Message );
-                AddLog( THROW_WHERE "Quiet exception" );
+                SAL_INFO("package.xstor", "Quiet exception: " << rException.Message);
             }
             m_pAntiImpl = nullptr;
         }
@@ -312,8 +310,7 @@ OStorage_Impl::~OStorage_Impl()
                         pStorageIter->m_pPointer->InternalDispose( false );
                     } catch( const uno::Exception& rException )
                     {
-                        AddLog( rException.Message );
-                        AddLog( THROW_WHERE "Quiet exception" );
+                        SAL_INFO("package.xstor", "Quiet exception: " << rException.Message);
                     }
             }
 
@@ -365,33 +362,14 @@ OStorage_Impl::~OStorage_Impl()
                     m_xStream.clear();
                 }
             }
-            catch( const uno::Exception& rException )
+            catch (const uno::Exception& rException)
             {
-                AddLog( THROW_WHERE "Quiet exception" );
-                AddLog( rException.Message );
+                SAL_INFO("package.xstor", "Quiet exception: " << rException.Message);
             }
         }
     }
 }
 
-void OStorage_Impl::AddLog( const OUString& aMessage )
-{
-    if ( !m_xLogRing.is() )
-    {
-        try
-        {
-            m_xLogRing = logging::DocumentIOLogRing::get(m_xContext);
-        }
-        catch( const uno::Exception& )
-        {
-            // No log
-        }
-    }
-
-    if ( m_xLogRing.is() )
-        m_xLogRing->logString( aMessage );
-}
-
 void OStorage_Impl::SetReadOnlyWrap( OStorage& aStorage )
 {
     // Weak reference is used inside the holder so the refcount must not be zero at this point
@@ -411,8 +389,7 @@ void OStorage_Impl::RemoveReadOnlyWrap( OStorage& aStorage )
                 pStorageIter->m_pPointer->InternalDispose( false );
             } catch( const uno::Exception& rException )
             {
-                AddLog( THROW_WHERE "Quiet exception" );
-                AddLog( rException.Message );
+                SAL_INFO("package.xstor", "Quiet exception: " << rException.Message);
             }
 
             StorageHoldersType::iterator pIterToDelete( pStorageIter );
@@ -639,10 +616,7 @@ void OStorage_Impl::ReadContents()
         }
         catch( const container::NoSuchElementException& rNoSuchElementException )
         {
-            AddLog( rNoSuchElementException.Message );
-            AddLog( THROW_WHERE "NoSuchElement" );
-
-            SAL_WARN( "package.xstor", "hasMoreElements() implementation has problems!" );
+            SAL_WARN( "package.xstor", "hasMoreElements() implementation has problems! " << rNoSuchElementException.Message);
             break;
         }
     }
@@ -716,8 +690,7 @@ void OStorage_Impl::CopyToStorage( const uno::Reference< embed::XStorage >& xDes
             }
             catch( const packages::NoEncryptionException& rNoEncryptionException )
             {
-                AddLog( rNoEncryptionException.Message );
-                AddLog( THROW_WHERE "No Encryption" );
+                SAL_INFO("package.xstor", "No Encryption: " << rNoEncryptionException.Message);
             }
         }
     }
@@ -881,8 +854,7 @@ void OStorage_Impl::CopyStorageElement( SotElement_Impl* pElement,
             }
             catch( const packages::NoEncryptionException& rNoEncryptionException )
             {
-                AddLog( rNoEncryptionException.Message );
-                AddLog( THROW_WHERE "No Encryption" );
+                SAL_INFO("package.xstor", "No Encryption: " << rNoEncryptionException.Message);
             }
 
             if (bHasCommonEncryptionData && ::package::PackageEncryptionDatasEqual(pElement->m_xStream->GetCachedEncryptionData(), aCommonEncryptionData))
@@ -936,8 +908,7 @@ void OStorage_Impl::CopyStorageElement( SotElement_Impl* pElement,
             }
             catch( const packages::WrongPasswordException& rWrongPasswordException )
             {
-                AddLog( rWrongPasswordException.Message );
-                AddLog( THROW_WHERE "Handled exception" );
+                SAL_INFO("package.xstor", "Handled exception: " << rWrongPasswordException.Message);
 
                 // If the common storage password does not allow to open the stream
                 // it could be copied in raw way, the problem is that the StartKey should be the same
@@ -1224,8 +1195,7 @@ void OStorage_Impl::Commit()
                 throw aException;
             }
 
-            AddLog( aException.Message );
-            AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << aException.Message);
             throw;
         }
     }
@@ -1853,8 +1823,7 @@ OStorage::~OStorage()
         }
         catch( const uno::RuntimeException& rRuntimeException )
         {
-            m_pImpl->AddLog( rRuntimeException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Handled exception" );
+            SAL_INFO("package.xstor", "Handled exception: " << rRuntimeException.Message);
         }
     }
 }
@@ -1899,8 +1868,7 @@ void SAL_CALL OStorage::InternalDispose( bool bNotifyImpl )
                             xTmp->dispose();
                         } catch( const uno::Exception& rException )
                         {
-                            m_pImpl->AddLog( rException.Message );
-                            m_pImpl->AddLog( THROW_WHERE "Quiet exception" );
+                            SAL_INFO("package.xstor", "Quiet exception: " << rException.Message);
                         }
                     }
                 }
@@ -2254,40 +2222,34 @@ void SAL_CALL OStorage::copyToStorage( const uno::Reference< embed::XStorage >&
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't copy storage!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -2332,46 +2294,39 @@ uno::Reference< io::XStream > SAL_CALL OStorage::openStreamElement(
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const packages::WrongPasswordException& rWrongPasswordException )
     {
-        m_pImpl->AddLog( rWrongPasswordException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rWrongPasswordException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException(THROW_WHERE "Can't open stream element!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -2491,40 +2446,34 @@ uno::Reference< embed::XStorage > SAL_CALL OStorage::openStorageElement(
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't open storage!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -2559,46 +2508,39 @@ uno::Reference< io::XStream > SAL_CALL OStorage::cloneStreamElement( const OUStr
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const packages::WrongPasswordException& rWrongPasswordException )
     {
-        m_pImpl->AddLog( rWrongPasswordException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rWrongPasswordException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't clone stream!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -2629,40 +2571,34 @@ void SAL_CALL OStorage::copyLastCommitTo(
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't copy last commit version!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -2720,40 +2656,34 @@ void SAL_CALL OStorage::copyStorageElementLastCommitTo(
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't copy last commit element version!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -2784,34 +2714,29 @@ sal_Bool SAL_CALL OStorage::isStreamElement( const OUString& aElementName )
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( rNoSuchElementException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoSuchElementException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw lang::WrappedTargetRuntimeException( THROW_WHERE "Can't detect whether it is a stream!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -2847,34 +2772,29 @@ sal_Bool SAL_CALL OStorage::isStorageElement( const OUString& aElementName )
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( rNoSuchElementException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoSuchElementException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw lang::WrappedTargetRuntimeException( THROW_WHERE "can't detect whether it is a storage",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -2919,46 +2839,39 @@ void SAL_CALL OStorage::removeElement( const OUString& aElementName )
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( rNoSuchElementException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoSuchElementException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't remove element!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -3006,52 +2919,44 @@ void SAL_CALL OStorage::renameElement( const OUString& aElementName, const OUStr
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( rNoSuchElementException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoSuchElementException.Message);
         throw;
     }
     catch( const container::ElementExistException& rElementExistException )
     {
-        m_pImpl->AddLog( rElementExistException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rElementExistException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't rename element!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -3099,52 +3004,44 @@ void SAL_CALL OStorage::copyElementTo(  const OUString& aElementName,
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( rNoSuchElementException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoSuchElementException.Message);
         throw;
     }
     catch( const container::ElementExistException& rElementExistException )
     {
-        m_pImpl->AddLog( rElementExistException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rElementExistException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't copy element!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -3195,52 +3092,44 @@ void SAL_CALL OStorage::moveElementTo(  const OUString& aElementName,
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( rNoSuchElementException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoSuchElementException.Message);
         throw;
     }
     catch( const container::ElementExistException& rElementExistException )
     {
-        m_pImpl->AddLog( rElementExistException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rElementExistException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't move element!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -3290,52 +3179,44 @@ uno::Reference< io::XStream > SAL_CALL OStorage::openEncryptedStream(
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const packages::NoEncryptionException& rNoEncryptionException )
     {
-        m_pImpl->AddLog( rNoEncryptionException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoEncryptionException.Message);
         throw;
     }
     catch( const packages::WrongPasswordException& rWrongPasswordException )
     {
-        m_pImpl->AddLog( rWrongPasswordException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rWrongPasswordException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't open encrypted stream stream!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -3376,52 +3257,44 @@ uno::Reference< io::XStream > SAL_CALL OStorage::cloneEncryptedStream(
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const packages::NoEncryptionException& rNoEncryptionException )
     {
-        m_pImpl->AddLog( rNoEncryptionException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoEncryptionException.Message);
         throw;
     }
     catch( const packages::WrongPasswordException& rWrongPasswordException )
     {
-        m_pImpl->AddLog( rWrongPasswordException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rWrongPasswordException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't clone encrypted stream!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -3479,46 +3352,39 @@ uno::Reference< io::XInputStream > SAL_CALL OStorage::getPlainRawStreamElement(
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( rNoSuchElementException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoSuchElementException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't get plain raw stream!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -3581,52 +3447,44 @@ uno::Reference< io::XInputStream > SAL_CALL OStorage::getRawEncrStreamElement(
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const packages::NoEncryptionException& rNoEncryptionException )
     {
-        m_pImpl->AddLog( rNoEncryptionException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoEncryptionException.Message);
         throw;
     }
     catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( rNoSuchElementException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoSuchElementException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't get raw stream!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -3668,52 +3526,44 @@ void SAL_CALL OStorage::insertRawEncrStreamElement( const OUString& aStreamName,
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const packages::NoRawFormatException& rNoRawFormatException )
     {
-        m_pImpl->AddLog( rNoRawFormatException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoRawFormatException.Message);
         throw;
     }
     catch( const container::ElementExistException& rElementExistException )
     {
-        m_pImpl->AddLog( rElementExistException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rElementExistException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't insert raw stream!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -3747,26 +3597,22 @@ void SAL_CALL OStorage::commit()
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-        m_pImpl->AddLog( rException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
         uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Problems on commit!",
@@ -3815,26 +3661,22 @@ void SAL_CALL OStorage::revert()
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-        m_pImpl->AddLog( rException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
         uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Problems on revert!",
@@ -3983,26 +3825,22 @@ uno::Any SAL_CALL OStorage::getByName( const OUString& aName )
     }
     catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( rNoSuchElementException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoSuchElementException.Message);
         throw;
     }
     catch( const lang::WrappedTargetException& rWrappedTargetException )
     {
-        m_pImpl->AddLog( rWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rWrappedTargetException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-        m_pImpl->AddLog( rException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
         uno::Any aCaught( ::cppu::getCaughtException() );
         throw lang::WrappedTargetException( THROW_WHERE "Can not open storage!",
@@ -4029,14 +3867,12 @@ uno::Sequence< OUString > SAL_CALL OStorage::getElementNames()
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch ( const uno::Exception& rException )
     {
-        m_pImpl->AddLog( rException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
         uno::Any aCaught( ::cppu::getCaughtException() );
         throw lang::WrappedTargetRuntimeException( THROW_WHERE "Can not open storage!",
@@ -4068,14 +3904,12 @@ sal_Bool SAL_CALL OStorage::hasByName( const OUString& aName )
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch ( const uno::Exception& rException )
     {
-        m_pImpl->AddLog( rException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
         uno::Any aCaught( ::cppu::getCaughtException() );
         throw lang::WrappedTargetRuntimeException( THROW_WHERE "Can not open storage!",
@@ -4116,14 +3950,12 @@ sal_Bool SAL_CALL OStorage::hasElements()
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-        m_pImpl->AddLog( rException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
         uno::Any aCaught( ::cppu::getCaughtException() );
         throw lang::WrappedTargetRuntimeException( THROW_WHERE "Can not open storage!",
@@ -4149,14 +3981,12 @@ void SAL_CALL OStorage::dispose()
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-        m_pImpl->AddLog( rException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
         uno::Any aCaught( ::cppu::getCaughtException() );
         throw lang::WrappedTargetRuntimeException( THROW_WHERE "Can not open storage!",
@@ -4223,14 +4053,12 @@ void SAL_CALL OStorage::removeEncryption()
         }
         catch ( const uno::RuntimeException& rRuntimeException )
         {
-            m_pImpl->AddLog( rRuntimeException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
             throw;
         }
         catch ( const uno::Exception& rException )
         {
-            m_pImpl->AddLog( rException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
             uno::Any aCaught( ::cppu::getCaughtException() );
             throw lang::WrappedTargetRuntimeException( THROW_WHERE "Can not open package!",
@@ -4252,16 +4080,14 @@ void SAL_CALL OStorage::removeEncryption()
         }
         catch( const uno::RuntimeException& rRException )
         {
-            m_pImpl->AddLog( rRException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << rRException.Message);
 
             SAL_WARN( "package.xstor", "The call must not fail, it is pretty simple!" );
             throw;
         }
         catch( const uno::Exception& rException )
         {
-            m_pImpl->AddLog( rException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
             SAL_WARN( "package.xstor", "The call must not fail, it is pretty simple!" );
             throw io::IOException( THROW_WHERE );
@@ -4295,14 +4121,12 @@ void SAL_CALL OStorage::setEncryptionData( const uno::Sequence< beans::NamedValu
         }
         catch ( const uno::RuntimeException& rRuntimeException )
         {
-            m_pImpl->AddLog( rRuntimeException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
             throw;
         }
         catch ( const uno::Exception& rException )
         {
-            m_pImpl->AddLog( rException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
             uno::Any aCaught( ::cppu::getCaughtException() );
             throw lang::WrappedTargetRuntimeException( THROW_WHERE "Can not open package!",
@@ -4322,8 +4146,7 @@ void SAL_CALL OStorage::setEncryptionData( const uno::Sequence< beans::NamedValu
         }
         catch( const uno::Exception& rException )
         {
-            m_pImpl->AddLog( rException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
             throw io::IOException( THROW_WHERE );
         }
@@ -4363,14 +4186,12 @@ void SAL_CALL OStorage::setEncryptionAlgorithms( const uno::Sequence< beans::Nam
         }
         catch ( const uno::RuntimeException& aRuntimeException )
         {
-            m_pImpl->AddLog( aRuntimeException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << aRuntimeException.Message);
             throw;
         }
         catch ( const uno::Exception& aException )
         {
-            m_pImpl->AddLog( aException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << aException.Message);
 
             uno::Any aCaught( ::cppu::getCaughtException() );
             throw lang::WrappedTargetRuntimeException( THROW_WHERE "Can not open package!",
@@ -4386,14 +4207,12 @@ void SAL_CALL OStorage::setEncryptionAlgorithms( const uno::Sequence< beans::Nam
         }
         catch ( const uno::RuntimeException& aRuntimeException )
         {
-            m_pImpl->AddLog( aRuntimeException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << aRuntimeException.Message);
             throw;
         }
         catch( const uno::Exception& aException )
         {
-            m_pImpl->AddLog( aException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << aException.Message);
 
             uno::Any aCaught( ::cppu::getCaughtException() );
             throw lang::WrappedTargetRuntimeException( THROW_WHERE "Can not open package!",
@@ -4425,14 +4244,12 @@ uno::Sequence< beans::NamedValue > SAL_CALL OStorage::getEncryptionAlgorithms()
         }
         catch ( const uno::RuntimeException& aRuntimeException )
         {
-            m_pImpl->AddLog( aRuntimeException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << aRuntimeException.Message);
             throw;
         }
         catch ( const uno::Exception& aException )
         {
-            m_pImpl->AddLog( aException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << aException.Message);
 
             uno::Any aCaught( ::cppu::getCaughtException() );
             throw lang::WrappedTargetRuntimeException( THROW_WHERE "Can not open package!",
@@ -4447,14 +4264,12 @@ uno::Sequence< beans::NamedValue > SAL_CALL OStorage::getEncryptionAlgorithms()
         }
         catch ( const uno::RuntimeException& aRuntimeException )
         {
-            m_pImpl->AddLog( aRuntimeException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << aRuntimeException.Message);
             throw;
         }
         catch( const uno::Exception& aException )
         {
-            m_pImpl->AddLog( aException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << aException.Message);
 
             uno::Any aCaught( ::cppu::getCaughtException() );
             throw lang::WrappedTargetRuntimeException( THROW_WHERE "Can not open package!",
@@ -4603,14 +4418,12 @@ uno::Any SAL_CALL OStorage::getPropertyValue( const OUString& aPropertyName )
         }
         catch ( const uno::RuntimeException& rRuntimeException )
         {
-            m_pImpl->AddLog( rRuntimeException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
             throw;
         }
         catch ( const uno::Exception& rException )
         {
-            m_pImpl->AddLog( rException.Message );
-            m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+            SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
             uno::Any aCaught( ::cppu::getCaughtException() );
             throw lang::WrappedTargetException(
@@ -4662,14 +4475,12 @@ uno::Any SAL_CALL OStorage::getPropertyValue( const OUString& aPropertyName )
             }
             catch ( const uno::RuntimeException& rRuntimeException )
             {
-                m_pImpl->AddLog( rRuntimeException.Message );
-                m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+                SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
                 throw;
             }
             catch ( const uno::Exception& rException )
             {
-                m_pImpl->AddLog( rException.Message );
-                m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+                SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
                 uno::Any aCaught( ::cppu::getCaughtException() );
                 throw lang::WrappedTargetException( THROW_WHERE "Can not open package!",
@@ -4766,8 +4577,7 @@ sal_Bool SAL_CALL OStorage::hasByID(  const OUString& sID )
     }
     catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( rNoSuchElementException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Quiet exception" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoSuchElementException.Message);
     }
 
     return false;
@@ -5154,46 +4964,39 @@ void SAL_CALL OStorage::insertStreamElementDirect(
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const container::ElementExistException& rElementExistException )
     {
-        m_pImpl->AddLog( rElementExistException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rElementExistException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't insert stream directly!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -5239,52 +5042,44 @@ void SAL_CALL OStorage::copyElementDirectlyTo(
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( rNoSuchElementException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoSuchElementException.Message);
         throw;
     }
     catch( const container::ElementExistException& rElementExistException )
     {
-        m_pImpl->AddLog( rElementExistException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rElementExistException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't copy element direcly!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -5313,40 +5108,34 @@ void SAL_CALL OStorage::writeAndAttachToStream( const uno::Reference< io::XStrea
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't write and attach to stream!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -5389,40 +5178,34 @@ void SAL_CALL OStorage::attachToURL( const OUString& sURL,
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't attach to URL!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -5466,58 +5249,49 @@ uno::Any SAL_CALL OStorage::getElementPropertyValue( const OUString& aElementNam
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const container::NoSuchElementException& rNoSuchElementException )
     {
-        m_pImpl->AddLog( rNoSuchElementException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rNoSuchElementException.Message);
         throw;
     }
     catch( const beans::UnknownPropertyException& rUnknownPropertyException )
     {
-        m_pImpl->AddLog( rUnknownPropertyException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rUnknownPropertyException.Message);
         throw;
     }
     catch( const beans::PropertyVetoException& rPropertyVetoException )
     {
-        m_pImpl->AddLog( rPropertyVetoException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rPropertyVetoException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't get element property!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
@@ -5554,46 +5328,39 @@ void SAL_CALL OStorage::copyStreamElementData( const OUString& aStreamName, cons
     }
     catch( const embed::InvalidStorageException& rInvalidStorageException )
     {
-        m_pImpl->AddLog( rInvalidStorageException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rInvalidStorageException.Message);
         throw;
     }
     catch( const lang::IllegalArgumentException& rIllegalArgumentException )
     {
-        m_pImpl->AddLog( rIllegalArgumentException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIllegalArgumentException.Message);
         throw;
     }
     catch( const packages::WrongPasswordException& rWrongPasswordException )
     {
-        m_pImpl->AddLog( rWrongPasswordException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rWrongPasswordException.Message);
         throw;
     }
     catch( const io::IOException& rIOException )
     {
-        m_pImpl->AddLog( rIOException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rIOException.Message);
         throw;
     }
     catch( const embed::StorageWrappedTargetException& rStorageWrappedTargetException )
     {
-        m_pImpl->AddLog( rStorageWrappedTargetException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rStorageWrappedTargetException.Message);
         throw;
     }
     catch( const uno::RuntimeException& rRuntimeException )
     {
-        m_pImpl->AddLog( rRuntimeException.Message );
-        m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rRuntimeException.Message);
         throw;
     }
     catch( const uno::Exception& rException )
     {
-          m_pImpl->AddLog( rException.Message );
-          m_pImpl->AddLog( THROW_WHERE "Rethrow" );
+        SAL_INFO("package.xstor", "Rethrow: " << rException.Message);
 
-          uno::Any aCaught( ::cppu::getCaughtException() );
+        uno::Any aCaught( ::cppu::getCaughtException() );
         throw embed::StorageWrappedTargetException( THROW_WHERE "Can't copy stream data!",
                                                  uno::Reference< io::XInputStream >(),
                                                  aCaught );
diff --git a/package/source/xstor/xstorage.hxx b/package/source/xstor/xstorage.hxx
index 568caf3b90c2..4fb4ed0900c6 100644
--- a/package/source/xstor/xstorage.hxx
+++ b/package/source/xstor/xstorage.hxx
@@ -42,7 +42,6 @@
 #include <com/sun/star/lang/XTypeProvider.hpp>
 #include <com/sun/star/lang/XComponent.hpp>
 #include <com/sun/star/packages/NoEncryptionException.hpp>
-#include <com/sun/star/logging/XSimpleLogRing.hpp>
 
 #include <cppuhelper/weak.hxx>
 #include <cppuhelper/weakref.hxx>
@@ -142,7 +141,6 @@ struct OStorage_Impl
     SotElementList_Impl                         m_aDeletedList;
 
     css::uno::Reference< css::container::XNameContainer > m_xPackageFolder;
-    css::uno::Reference< css::logging::XSimpleLogRing >  m_xLogRing;
 
     css::uno::Reference< css::lang::XSingleServiceFactory > m_xPackage;
     css::uno::Reference< css::uno::XComponentContext >  m_xContext;
@@ -198,8 +196,6 @@ struct OStorage_Impl
 
     ~OStorage_Impl();
 
-    void AddLog( const OUString& aMessage );
-
     void SetReadOnlyWrap( OStorage& aStorage );
     void RemoveReadOnlyWrap( OStorage& aStorage );