Use sal::systools::COMReference in connectivity/ado

Change-Id: Ic3c59f70cf0e1ed0020bf4f11d7dee14c69f2119
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/127189
Tested-by: Jenkins
Reviewed-by: Mike Kaganski <mike.kaganski@collabora.com>

1 files changed, 31 insertions, 78 deletions

diff --git a/connectivity/source/inc/ado/Aolewrap.hxx b/connectivity/source/inc/ado/Aolewrap.hxx
index 767c50372254..9d402fcf21b1 100644
--- a/connectivity/source/inc/ado/Aolewrap.hxx
+++ b/connectivity/source/inc/ado/Aolewrap.hxx
@@ -20,6 +20,8 @@
 
 #include <osl/diagnose.h>
 #include <osl/thread.h>
+#include <systools/win32/comtools.hxx>
+
 #include <map>
 #include <vector>
 
@@ -31,101 +33,59 @@ namespace rtl
 }
 namespace connectivity::ado
 {
-        class WpBase
-        {
-        protected:
-            IDispatch* pIUnknown;
-
-            void setIDispatch(IDispatch* _pIUnknown);
-        public:
-            WpBase();
-            WpBase(IDispatch* pInt);
-            //inline
-            WpBase& operator=(const WpBase& rhs);
-            WpBase& operator=(IDispatch* rhs);
-            WpBase(const WpBase& aWrapper);
-            virtual ~WpBase();
-            void clear();
-
-
-            bool IsValid() const;
-            operator IDispatch*();
-
-        };
-
         // Template class WpOLEBase<class T>
         // ==================================
         //
         // Objects of this class contain a pointer to an interface of the type T.
-        // The ctors and operator= make sure, that AddRef() and Release() are being
-        // called adhering to COM conventions.
-        // An object can also hold no pointer (null pointer), calling IsValid() then
-        // returns false.
-        //
-        // In order to do efficient pass-by-value, this class (as all derived classes)
-        // is a thin wrapper class, avoiding virtual methods and inlining.
 
-        template<class T> class WpOLEBase : public WpBase
+        template<class T> class WpOLEBase
         {
         protected:
-            T* pInterface;
+            sal::systools::COMReference<T> pInterface;
 
         public:
-            WpOLEBase(T* pInt = nullptr) : WpBase(pInt),pInterface(pInt){}
+            WpOLEBase(T* pInt = nullptr) : pInterface(pInt){}
 
+            WpOLEBase(const WpOLEBase<T>& aWrapper)
+                : pInterface( aWrapper.pInterface )
+            {
+            }
 
             //inline
             WpOLEBase<T>& operator=(const WpOLEBase<T>& rhs)
             {
-                WpBase::operator=(rhs);
                 pInterface = rhs.pInterface;
                 return *this;
             };
 
-            WpOLEBase<T>& operator=(T* rhs)
-            {
-                WpBase::operator=(rhs);
-                pInterface = rhs.pInterface;
-                return *this;
-            }
-
-            WpOLEBase(const WpOLEBase<T>& aWrapper)
-                : WpBase( aWrapper )
-                , pInterface( aWrapper.pInterface )
-            {
-            }
-
-            operator T*() const { return pInterface; }
-            void setWithOutAddRef(T* _pInterface)
-            {
-                pInterface = _pInterface;
-                WpBase::setIDispatch(_pInterface);
-            }
+            operator T*() const { return pInterface.get(); }
+            T** operator&() { return &pInterface; }
+            bool IsValid() const { return pInterface.is(); }
+            void set(T* p) { pInterface = p; }
+            void clear() { pInterface.clear(); }
         };
 
 
-        // Template class WpOLECollection<class Ts, class T, class WrapT>
+        // Template class WpOLECollection<class Ts, class WrapT>
         // ===============================================================
         //
         // This class (derived from WpOLEBase<Ts>), abstracts away the properties
         // common to DAO collections:
         //
         // They are accessed via an interface Ts (e.g. DAOFields) and can return
-        // Items of the Type T (actually: with the interface T, e.g. DAOField)
-        // via get_Item (here GetItem).
+        // Items of the type wrapped by WrapT (actually: with the interface, e.g.
+        // DAOField) via get_Item (here GetItem).
         //
-        // This wrapper class does not expose an interface T, however,
-        // it exposes an object of the class WrapT. This must allow a construction
-        // by T, preferably it is derived from WpOLEBase<T>.
+        // This wrapper class exposes an object of the class WrapT.
 
-        template<class Ts, class T, class WrapT> class WpOLECollection : public WpOLEBase<Ts>
+        template<class Ts, class WrapT> class WpOLECollection : public WpOLEBase<Ts>
         {
         public:
             using WpOLEBase<Ts>::pInterface;
             using WpOLEBase<Ts>::IsValid;
             // Ctors, operator=
             // They only call the superclass
-            WpOLECollection(Ts* pInt=nullptr):WpOLEBase<Ts>(pInt){}
+            WpOLECollection() = default;
             WpOLECollection(const WpOLECollection& rhs) : WpOLEBase<Ts>(rhs) {}
             WpOLECollection& operator=(const WpOLECollection& rhs)
                 {WpOLEBase<Ts>::operator=(rhs); return *this;};
@@ -142,35 +102,28 @@ namespace connectivity::ado
             WrapT GetItem(sal_Int32 index) const
             {
                 OSL_ENSURE(index >= 0 && index<GetItemCount(),"Wrong index for field!");
-                T* pT = NULL;
-                WrapT aRet(NULL);
-                if(SUCCEEDED(pInterface->get_Item(OLEVariant(index), &pT)))
-                    aRet.setWithOutAddRef(pT);
+                WrapT aRet;
+                pInterface->get_Item(OLEVariant(index), &aRet);
                 return aRet;
             }
 
             WrapT GetItem(const OLEVariant& index) const
             {
-                T* pT = NULL;
-                WrapT aRet(NULL);
-                if(SUCCEEDED(pInterface->get_Item(index, &pT)))
-                    aRet.setWithOutAddRef(pT);
+                WrapT aRet;
+                pInterface->get_Item(index, &aRet);
                 return aRet;
             }
 
             WrapT GetItem(const OUString& sStr) const
             {
-                WrapT aRet(NULL);
-                T* pT = NULL;
-                if (FAILED(pInterface->get_Item(OLEVariant(sStr), &pT)))
+                WrapT aRet;
+                if (FAILED(pInterface->get_Item(OLEVariant(sStr), &aRet)))
                 {
 #if OSL_DEBUG_LEVEL > 0
                     OString sTemp("Unknown Item: " + OString(sStr.getStr(),sStr.getLength(),osl_getThreadTextEncoding()));
                     OSL_FAIL(sTemp.getStr());
 #endif
                 }
-                else
-                    aRet.setWithOutAddRef(pT);
                 return aRet;
             }
             void fillElementNames(::std::vector< OUString>& _rVector)
@@ -190,23 +143,23 @@ namespace connectivity::ado
             }
         };
 
-        template<class Ts, class T, class WrapT> class WpOLEAppendCollection:
-                public WpOLECollection<Ts,T,WrapT>
+        template<class Ts, class WrapT> class WpOLEAppendCollection:
+                public WpOLECollection<Ts,WrapT>
         {
 
         public:
             // Ctors, operator=
             // They only call the superclass
             using WpOLEBase<Ts>::pInterface;
-            WpOLEAppendCollection(Ts* pInt=nullptr):WpOLECollection<Ts,T,WrapT>(pInt){}
-            WpOLEAppendCollection(const WpOLEAppendCollection& rhs) : WpOLECollection<Ts, T, WrapT>(rhs) {}
+            WpOLEAppendCollection() = default;
+            WpOLEAppendCollection(const WpOLEAppendCollection& rhs) : WpOLECollection<Ts, WrapT>(rhs) {}
             WpOLEAppendCollection& operator=(const WpOLEAppendCollection& rhs)
                 {WpOLEBase<Ts>::operator=(rhs); return *this;};
 
 
             bool Append(const WrapT& aWrapT)
             {
-                return SUCCEEDED(pInterface->Append(OLEVariant(static_cast<T*>(aWrapT))));
+                return SUCCEEDED(pInterface->Append(OLEVariant(aWrapT)));
             };
 
             bool Delete(const OUString& sName)