Port from QScopedPointer to std::unique_ptr

The swap() in QSerialPortPrivate/Unix is actually deprecated. But
instead of fixing yet one more QScopedPointer, I've fixed them all.

Also simplified the udev deleters by using a statically-polymophic
deleter.

QScopedPointer::swap() is deperecated since 6.1, so

Change-Id: I5ceeeb8e13bc080afa5dc46a1421038a1169f30e
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
Reviewed-by: Sona Kurazyan <sona.kurazyan@qt.io>
(cherry picked from commit 28143c4137ec0560a43dcc0b2cf80334651faa43)
Reviewed-by: Qt Cherry-pick Bot <cherrypick_bot@qt-project.org>

3 files changed, 28 insertions, 34 deletions

diff --git a/src/serialport/qserialport_p.h b/src/serialport/qserialport_p.h
index cb2007d4..e57f4e27 100644
--- a/src/serialport/qserialport_p.h
+++ b/src/serialport/qserialport_p.h
@@ -60,11 +60,12 @@
 #include <private/qiodevice_p.h>
 #include <private/qproperty_p.h>
 
+#include <memory>
+
 #if defined(Q_OS_WIN32)
 #  include <qt_windows.h>
 #elif defined(Q_OS_UNIX)
 #  include <QtCore/qlockfile.h>
-#  include <QtCore/qscopedpointer.h>
 #  include <QtCore/qfileinfo.h>
 #  include <QtCore/qstringlist.h>
 #  include <limits.h>
@@ -287,7 +288,7 @@ public:
     qint64 pendingBytesWritten = 0;
     bool writeSequenceStarted = false;
 
-    QScopedPointer<QLockFile> lockFileScopedPointer;
+    std::unique_ptr<QLockFile> lockFileScopedPointer;
 
 #endif
 };
diff --git a/src/serialport/qserialport_unix.cpp b/src/serialport/qserialport_unix.cpp
index 294782b5..7605fcb4 100644
--- a/src/serialport/qserialport_unix.cpp
+++ b/src/serialport/qserialport_unix.cpp
@@ -316,7 +316,7 @@ bool QSerialPortPrivate::open(QIODevice::OpenMode mode)
         return false;
     }
 
-    QScopedPointer<QLockFile> newLockFileScopedPointer(new QLockFile(lockFilePath));
+    auto newLockFileScopedPointer = std::make_unique<QLockFile>(lockFilePath);
 
     if (!newLockFileScopedPointer->tryLock()) {
         setError(QSerialPortErrorInfo(QSerialPort::PermissionError, QSerialPort::tr("Permission error while locking the device")));
@@ -349,7 +349,7 @@ bool QSerialPortPrivate::open(QIODevice::OpenMode mode)
         return false;
     }
 
-    lockFileScopedPointer.swap(newLockFileScopedPointer);
+    lockFileScopedPointer = std::move(newLockFileScopedPointer);
 
     return true;
 }
diff --git a/src/serialport/qserialportinfo_unix.cpp b/src/serialport/qserialportinfo_unix.cpp
index 93760e22..7239cdb9 100644
--- a/src/serialport/qserialportinfo_unix.cpp
+++ b/src/serialport/qserialportinfo_unix.cpp
@@ -46,10 +46,11 @@
 #include <QtCore/qlockfile.h>
 #include <QtCore/qfile.h>
 #include <QtCore/qdir.h>
-#include <QtCore/qscopedpointer.h>
 
 #include <private/qcore_unix_p.h>
 
+#include <memory>
+
 #include <errno.h>
 #include <sys/types.h> // kill
 #include <signal.h>    // kill
@@ -313,29 +314,22 @@ QList<QSerialPortInfo> availablePortsBySysfs(bool &ok)
     return serialPortInfoList;
 }
 
-struct ScopedPointerUdevDeleter
-{
-    static inline void cleanup(struct ::udev *pointer)
+struct udev_deleter {
+    void operator()(struct ::udev *pointer) const
     {
         ::udev_unref(pointer);
     }
-};
-
-struct ScopedPointerUdevEnumeratorDeleter
-{
-    static inline void cleanup(struct ::udev_enumerate *pointer)
+    void operator()(struct ::udev_enumerate *pointer) const
     {
         ::udev_enumerate_unref(pointer);
     }
-};
-
-struct ScopedPointerUdevDeviceDeleter
-{
-    static inline void cleanup(struct ::udev_device *pointer)
+    void operator()(struct ::udev_device *pointer) const
     {
         ::udev_device_unref(pointer);
     }
 };
+template <typename T>
+using udev_ptr = std::unique_ptr<T, udev_deleter>;
 
 #ifndef LINK_LIBUDEV
     Q_GLOBAL_STATIC(QLibrary, udevLibrary)
@@ -396,21 +390,20 @@ QList<QSerialPortInfo> availablePortsByUdev(bool &ok)
         return QList<QSerialPortInfo>();
 #endif
 
-    QScopedPointer<struct ::udev, ScopedPointerUdevDeleter> udev(::udev_new());
+    const udev_ptr<struct ::udev> udev(::udev_new());
 
     if (!udev)
         return QList<QSerialPortInfo>();
 
-    QScopedPointer<udev_enumerate, ScopedPointerUdevEnumeratorDeleter>
-            enumerate(::udev_enumerate_new(udev.data()));
+    const udev_ptr<udev_enumerate> enumerate(::udev_enumerate_new(udev.get()));
 
     if (!enumerate)
         return QList<QSerialPortInfo>();
 
-    ::udev_enumerate_add_match_subsystem(enumerate.data(), "tty");
-    ::udev_enumerate_scan_devices(enumerate.data());
+    ::udev_enumerate_add_match_subsystem(enumerate.get(), "tty");
+    ::udev_enumerate_scan_devices(enumerate.get());
 
-    udev_list_entry *devices = ::udev_enumerate_get_list_entry(enumerate.data());
+    udev_list_entry *devices = ::udev_enumerate_get_list_entry(enumerate.get());
 
     QList<QSerialPortInfo> serialPortInfoList;
     udev_list_entry *dev_list_entry;
@@ -418,29 +411,29 @@ QList<QSerialPortInfo> availablePortsByUdev(bool &ok)
 
         ok = true;
 
-        QScopedPointer<udev_device, ScopedPointerUdevDeviceDeleter>
+        const udev_ptr<udev_device>
                 dev(::udev_device_new_from_syspath(
-                        udev.data(), ::udev_list_entry_get_name(dev_list_entry)));
+                        udev.get(), ::udev_list_entry_get_name(dev_list_entry)));
 
         if (!dev)
             return serialPortInfoList;
 
         QSerialPortInfoPrivate priv;
 
-        priv.device = deviceLocation(dev.data());
-        priv.portName = deviceName(dev.data());
+        priv.device = deviceLocation(dev.get());
+        priv.portName = deviceName(dev.get());
 
-        udev_device *parentdev = ::udev_device_get_parent(dev.data());
+        udev_device *parentdev = ::udev_device_get_parent(dev.get());
 
         if (parentdev) {
             const QString driverName = deviceDriver(parentdev);
             if (isSerial8250Driver(driverName) && !isValidSerial8250(priv.device))
                 continue;
-            priv.description = deviceDescription(dev.data());
-            priv.manufacturer = deviceManufacturer(dev.data());
-            priv.serialNumber = deviceSerialNumber(dev.data());
-            priv.vendorIdentifier = deviceVendorIdentifier(dev.data(), priv.hasVendorIdentifier);
-            priv.productIdentifier = deviceProductIdentifier(dev.data(), priv.hasProductIdentifier);
+            priv.description = deviceDescription(dev.get());
+            priv.manufacturer = deviceManufacturer(dev.get());
+            priv.serialNumber = deviceSerialNumber(dev.get());
+            priv.vendorIdentifier = deviceVendorIdentifier(dev.get(), priv.hasVendorIdentifier);
+            priv.productIdentifier = deviceProductIdentifier(dev.get(), priv.hasProductIdentifier);
         } else {
             if (!isRfcommDevice(priv.portName)
                     && !isVirtualNullModemDevice(priv.portName)