IVGCVSW-4065 Refactor the IPacketBuffer smart pointers

 * Added convenience "using" statement for the unique pointers to
   IPacketBuffer
 * Replaced all the occurrencies in the code

Signed-off-by: Matteo Martincigh <matteo.martincigh@arm.com>
Change-Id: Iffec3a425ffbc1ecb23012971563a48139eb32eb

11 files changed, 62 insertions, 60 deletions

diff --git a/src/profiling/BufferManager.cpp b/src/profiling/BufferManager.cpp
index 6ac3ee17d1..6481c5e9cb 100644
--- a/src/profiling/BufferManager.cpp
+++ b/src/profiling/BufferManager.cpp
@@ -21,13 +21,13 @@ BufferManager::BufferManager(unsigned int numberOfBuffers, unsigned int maxPacke
     m_AvailableList.reserve(numberOfBuffers);
     for (unsigned int i = 0; i < numberOfBuffers; ++i)
     {
-        std::unique_ptr<IPacketBuffer> buffer = std::make_unique<PacketBuffer>(maxPacketSize);
+        IPacketBufferPtr buffer = std::make_unique<PacketBuffer>(maxPacketSize);
         m_AvailableList.emplace_back(std::move(buffer));
     }
     m_ReadableList.reserve(numberOfBuffers);
 }
 
-std::unique_ptr<IPacketBuffer> BufferManager::Reserve(unsigned int requestedSize, unsigned int& reservedSize)
+IPacketBufferPtr BufferManager::Reserve(unsigned int requestedSize, unsigned int& reservedSize)
 {
     reservedSize = 0;
     std::unique_lock<std::mutex> availableListLock(m_AvailableMutex, std::defer_lock);
@@ -41,14 +41,14 @@ std::unique_ptr<IPacketBuffer> BufferManager::Reserve(unsigned int requestedSize
         availableListLock.unlock();
         return nullptr;
     }
-    std::unique_ptr<IPacketBuffer> buffer = std::move(m_AvailableList.back());
+    IPacketBufferPtr buffer = std::move(m_AvailableList.back());
     m_AvailableList.pop_back();
     availableListLock.unlock();
     reservedSize = requestedSize;
     return buffer;
 }
 
-void BufferManager::Commit(std::unique_ptr<IPacketBuffer>& packetBuffer, unsigned int size)
+void BufferManager::Commit(IPacketBufferPtr& packetBuffer, unsigned int size)
 {
     std::unique_lock<std::mutex> readableListLock(m_ReadableMutex, std::defer_lock);
     packetBuffer->Commit(size);
@@ -58,7 +58,7 @@ void BufferManager::Commit(std::unique_ptr<IPacketBuffer>& packetBuffer, unsigne
     m_ReadDataAvailable.notify_one();
 }
 
-void BufferManager::Release(std::unique_ptr<IPacketBuffer>& packetBuffer)
+void BufferManager::Release(IPacketBufferPtr& packetBuffer)
 {
     std::unique_lock<std::mutex> availableListLock(m_AvailableMutex, std::defer_lock);
     packetBuffer->Release();
@@ -67,12 +67,12 @@ void BufferManager::Release(std::unique_ptr<IPacketBuffer>& packetBuffer)
     availableListLock.unlock();
 }
 
-std::unique_ptr<IPacketBuffer> BufferManager::GetReadableBuffer()
+IPacketBufferPtr BufferManager::GetReadableBuffer()
 {
     std::unique_lock<std::mutex> readableListLock(m_ReadableMutex);
     if (!m_ReadableList.empty())
     {
-        std::unique_ptr<IPacketBuffer> buffer = std::move(m_ReadableList.back());
+        IPacketBufferPtr buffer = std::move(m_ReadableList.back());
         m_ReadableList.pop_back();
         readableListLock.unlock();
         return buffer;
@@ -80,7 +80,7 @@ std::unique_ptr<IPacketBuffer> BufferManager::GetReadableBuffer()
     return nullptr;
 }
 
-void BufferManager::MarkRead(std::unique_ptr<IPacketBuffer>& packetBuffer)
+void BufferManager::MarkRead(IPacketBufferPtr& packetBuffer)
 {
     std::unique_lock<std::mutex> availableListLock(m_AvailableMutex, std::defer_lock);
     packetBuffer->MarkRead();
diff --git a/src/profiling/BufferManager.hpp b/src/profiling/BufferManager.hpp
index 04a1507512..afa4240f14 100644
--- a/src/profiling/BufferManager.hpp
+++ b/src/profiling/BufferManager.hpp
@@ -24,25 +24,25 @@ public:
 
     ~BufferManager() {}
 
-    std::unique_ptr<IPacketBuffer> Reserve(unsigned int requestedSize, unsigned int& reservedSize) override;
+    IPacketBufferPtr Reserve(unsigned int requestedSize, unsigned int& reservedSize) override;
 
-    void Commit(std::unique_ptr<IPacketBuffer>& packetBuffer, unsigned int size) override;
+    void Commit(IPacketBufferPtr& packetBuffer, unsigned int size) override;
 
-    void Release(std::unique_ptr<IPacketBuffer>& packetBuffer) override;
+    void Release(IPacketBufferPtr& packetBuffer) override;
 
-    std::unique_ptr<IPacketBuffer> GetReadableBuffer() override;
+    IPacketBufferPtr GetReadableBuffer() override;
 
-    void MarkRead(std::unique_ptr<IPacketBuffer>& packetBuffer) override;
+    void MarkRead(IPacketBufferPtr& packetBuffer) override;
 
 private:
     // Maximum buffer size
     unsigned int m_MaxBufferSize;
 
     // List of available packet buffers
-    std::vector<std::unique_ptr<IPacketBuffer>> m_AvailableList;
+    std::vector<IPacketBufferPtr> m_AvailableList;
 
     // List of readable packet buffers
-    std::vector<std::unique_ptr<IPacketBuffer>> m_ReadableList;
+    std::vector<IPacketBufferPtr> m_ReadableList;
 
     // Mutex for available packet buffer list
     std::mutex m_AvailableMutex;
diff --git a/src/profiling/IBufferManager.hpp b/src/profiling/IBufferManager.hpp
index c35d9c6f3d..2b497da585 100644
--- a/src/profiling/IBufferManager.hpp
+++ b/src/profiling/IBufferManager.hpp
@@ -22,15 +22,15 @@ class IBufferManager
 public:
     virtual ~IBufferManager() {}
 
-    virtual std::unique_ptr<IPacketBuffer> Reserve(unsigned int requestedSize, unsigned int& reservedSize) = 0;
+    virtual IPacketBufferPtr Reserve(unsigned int requestedSize, unsigned int& reservedSize) = 0;
 
-    virtual void Commit(std::unique_ptr<IPacketBuffer>& packetBuffer, unsigned int size) = 0;
+    virtual void Commit(IPacketBufferPtr& packetBuffer, unsigned int size) = 0;
 
-    virtual void Release(std::unique_ptr<IPacketBuffer>& packetBuffer) = 0;
+    virtual void Release(IPacketBufferPtr& packetBuffer) = 0;
 
-    virtual std::unique_ptr<IPacketBuffer> GetReadableBuffer() = 0;
+    virtual IPacketBufferPtr GetReadableBuffer() = 0;
 
-    virtual void MarkRead(std::unique_ptr<IPacketBuffer>& packetBuffer) = 0;
+    virtual void MarkRead(IPacketBufferPtr& packetBuffer) = 0;
 };
 
 } // namespace profiling
diff --git a/src/profiling/IPacketBuffer.hpp b/src/profiling/IPacketBuffer.hpp
index b4bd615bab..c61d2327f4 100644
--- a/src/profiling/IPacketBuffer.hpp
+++ b/src/profiling/IPacketBuffer.hpp
@@ -5,6 +5,8 @@
 
 #pragma once
 
+#include <memory>
+
 namespace armnn
 {
 
@@ -35,6 +37,8 @@ public:
     virtual unsigned char* GetWritableData() = 0;
 };
 
+using IPacketBufferPtr = std::unique_ptr<IPacketBuffer>;
+
 } // namespace profiling
 
-} // namespace armnn
\ No newline at end of file
+} // namespace armnn
diff --git a/src/profiling/ProfilingUtils.cpp b/src/profiling/ProfilingUtils.cpp
index 905ecb559d..ef72feba5f 100644
--- a/src/profiling/ProfilingUtils.cpp
+++ b/src/profiling/ProfilingUtils.cpp
@@ -87,21 +87,21 @@ std::vector<uint16_t> GetNextCounterUids(uint16_t cores)
     return counterUids;
 }
 
-void WriteUint64(const std::unique_ptr<IPacketBuffer>& packetBuffer, unsigned int offset, uint64_t value)
+void WriteUint64(const IPacketBufferPtr& packetBuffer, unsigned int offset, uint64_t value)
 {
     BOOST_ASSERT(packetBuffer);
 
     WriteUint64(packetBuffer->GetWritableData(), offset, value);
 }
 
-void WriteUint32(const std::unique_ptr<IPacketBuffer>& packetBuffer, unsigned int offset, uint32_t value)
+void WriteUint32(const IPacketBufferPtr& packetBuffer, unsigned int offset, uint32_t value)
 {
     BOOST_ASSERT(packetBuffer);
 
     WriteUint32(packetBuffer->GetWritableData(), offset, value);
 }
 
-void WriteUint16(const std::unique_ptr<IPacketBuffer>& packetBuffer, unsigned int offset, uint16_t value)
+void WriteUint16(const IPacketBufferPtr& packetBuffer, unsigned int offset, uint16_t value)
 {
     BOOST_ASSERT(packetBuffer);
 
@@ -140,28 +140,28 @@ void WriteUint16(unsigned char* buffer, unsigned int offset, uint16_t value)
     buffer[offset + 1] = static_cast<unsigned char>((value >> 8) & 0xFF);
 }
 
-uint64_t ReadUint64(const std::unique_ptr<IPacketBuffer>& packetBuffer, unsigned int offset)
+uint64_t ReadUint64(const IPacketBufferPtr& packetBuffer, unsigned int offset)
 {
     BOOST_ASSERT(packetBuffer);
 
     return ReadUint64(packetBuffer->GetReadableData(), offset);
 }
 
-uint32_t ReadUint32(const std::unique_ptr<IPacketBuffer>& packetBuffer, unsigned int offset)
+uint32_t ReadUint32(const IPacketBufferPtr& packetBuffer, unsigned int offset)
 {
     BOOST_ASSERT(packetBuffer);
 
     return ReadUint32(packetBuffer->GetReadableData(), offset);
 }
 
-uint16_t ReadUint16(const std::unique_ptr<IPacketBuffer>& packetBuffer, unsigned int offset)
+uint16_t ReadUint16(const IPacketBufferPtr& packetBuffer, unsigned int offset)
 {
     BOOST_ASSERT(packetBuffer);
 
     return ReadUint16(packetBuffer->GetReadableData(), offset);
 }
 
-uint8_t ReadUint8(const std::unique_ptr<IPacketBuffer>& packetBuffer, unsigned int offset)
+uint8_t ReadUint8(const IPacketBufferPtr& packetBuffer, unsigned int offset)
 {
     BOOST_ASSERT(packetBuffer);
 
@@ -292,7 +292,7 @@ uint32_t CalculateSizeOfPaddedSwString(const std::string& str)
 }
 
 // Read TimelineMessageDirectoryPacket from given IPacketBuffer and offset
-SwTraceMessage ReadSwTraceMessage(const std::unique_ptr<IPacketBuffer>& packetBuffer, unsigned int& offset)
+SwTraceMessage ReadSwTraceMessage(const IPacketBufferPtr& packetBuffer, unsigned int& offset)
 {
     BOOST_ASSERT(packetBuffer);
 
diff --git a/src/profiling/ProfilingUtils.hpp b/src/profiling/ProfilingUtils.hpp
index 777711a634..78ac43e0b3 100644
--- a/src/profiling/ProfilingUtils.hpp
+++ b/src/profiling/ProfilingUtils.hpp
@@ -92,11 +92,11 @@ uint16_t GetNextUid(bool peekOnly = false);
 
 std::vector<uint16_t> GetNextCounterUids(uint16_t cores);
 
-void WriteUint64(const std::unique_ptr<IPacketBuffer>& packetBuffer, unsigned int offset, uint64_t value);
+void WriteUint64(const IPacketBufferPtr& packetBuffer, unsigned int offset, uint64_t value);
 
-void WriteUint32(const std::unique_ptr<IPacketBuffer>& packetBuffer, unsigned int offset, uint32_t value);
+void WriteUint32(const IPacketBufferPtr& packetBuffer, unsigned int offset, uint32_t value);
 
-void WriteUint16(const std::unique_ptr<IPacketBuffer>& packetBuffer, unsigned int offset, uint16_t value);
+void WriteUint16(const IPacketBufferPtr& packetBuffer, unsigned int offset, uint16_t value);
 
 void WriteUint64(unsigned char* buffer, unsigned int offset, uint64_t value);
 
@@ -104,13 +104,13 @@ void WriteUint32(unsigned char* buffer, unsigned int offset, uint32_t value);
 
 void WriteUint16(unsigned char* buffer, unsigned int offset, uint16_t value);
 
-uint64_t ReadUint64(const std::unique_ptr<IPacketBuffer>& packetBuffer, unsigned int offset);
+uint64_t ReadUint64(const IPacketBufferPtr& packetBuffer, unsigned int offset);
 
-uint32_t ReadUint32(const std::unique_ptr<IPacketBuffer>& packetBuffer, unsigned int offset);
+uint32_t ReadUint32(const IPacketBufferPtr& packetBuffer, unsigned int offset);
 
-uint16_t ReadUint16(const std::unique_ptr<IPacketBuffer>& packetBuffer, unsigned int offset);
+uint16_t ReadUint16(const IPacketBufferPtr& packetBuffer, unsigned int offset);
 
-uint8_t ReadUint8(const std::unique_ptr<IPacketBuffer>& packetBuffer, unsigned int offset);
+uint8_t ReadUint8(const IPacketBufferPtr& packetBuffer, unsigned int offset);
 
 uint64_t ReadUint64(unsigned const char* buffer, unsigned int offset);
 
@@ -145,7 +145,7 @@ enum class ProfilingRelationshipType
 
 uint32_t CalculateSizeOfPaddedSwString(const std::string& str);
 
-SwTraceMessage ReadSwTraceMessage(const std::unique_ptr<IPacketBuffer>& packetBuffer, unsigned int& offset);
+SwTraceMessage ReadSwTraceMessage(const IPacketBufferPtr& packetBuffer, unsigned int& offset);
 
 TimelinePacketStatus WriteTimelineLabelBinaryPacket(uint64_t profilingGuid,
                                                     const std::string& label,
diff --git a/src/profiling/SendCounterPacket.cpp b/src/profiling/SendCounterPacket.cpp
index dcba156e93..1ed926b6d7 100644
--- a/src/profiling/SendCounterPacket.cpp
+++ b/src/profiling/SendCounterPacket.cpp
@@ -64,7 +64,7 @@ void SendCounterPacket::SendStreamMetaDataPacket()
     uint32_t offset = 0;
     uint32_t reserved = 0;
 
-    std::unique_ptr<IPacketBuffer> writeBuffer = m_BufferManager.Reserve(totalSize, reserved);
+    IPacketBufferPtr writeBuffer = m_BufferManager.Reserve(totalSize, reserved);
 
     if (writeBuffer == nullptr || reserved < totalSize)
     {
@@ -786,7 +786,7 @@ void SendCounterPacket::SendCounterDirectoryPacket(const ICounterDirectory& coun
 
     // Reserve space in the buffer for the packet
     uint32_t reserved = 0;
-    std::unique_ptr<IPacketBuffer> writeBuffer = m_BufferManager.Reserve(totalSize, reserved);
+    IPacketBufferPtr writeBuffer = m_BufferManager.Reserve(totalSize, reserved);
 
     if (writeBuffer == nullptr || reserved < totalSize)
     {
@@ -823,7 +823,7 @@ void SendCounterPacket::SendPeriodicCounterCapturePacket(uint64_t timestamp, con
     uint32_t offset = 0;
     uint32_t reserved = 0;
 
-    std::unique_ptr<IPacketBuffer> writeBuffer = m_BufferManager.Reserve(totalSize, reserved);
+    IPacketBufferPtr writeBuffer = m_BufferManager.Reserve(totalSize, reserved);
 
     if (writeBuffer == nullptr || reserved < totalSize)
     {
@@ -872,7 +872,7 @@ void SendCounterPacket::SendPeriodicCounterSelectionPacket(uint32_t capturePerio
     uint32_t offset = 0;
     uint32_t reserved = 0;
 
-    std::unique_ptr<IPacketBuffer> writeBuffer = m_BufferManager.Reserve(totalSize, reserved);
+    IPacketBufferPtr writeBuffer = m_BufferManager.Reserve(totalSize, reserved);
 
     if (writeBuffer == nullptr || reserved < totalSize)
     {
@@ -1056,7 +1056,7 @@ void SendCounterPacket::Send(IProfilingConnection& profilingConnection)
 void SendCounterPacket::FlushBuffer(IProfilingConnection& profilingConnection, bool notifyWatchers)
 {
     // Get the first available readable buffer
-    std::unique_ptr<IPacketBuffer> packetBuffer = m_BufferManager.GetReadableBuffer();
+    IPacketBufferPtr packetBuffer = m_BufferManager.GetReadableBuffer();
 
     // Initialize the flag that indicates whether at least a packet has been sent
     bool packetsSent = false;
diff --git a/src/profiling/SendCounterPacket.hpp b/src/profiling/SendCounterPacket.hpp
index 2aaabc8397..102cbccc84 100644
--- a/src/profiling/SendCounterPacket.hpp
+++ b/src/profiling/SendCounterPacket.hpp
@@ -83,7 +83,7 @@ private:
     }
 
     template <typename ExceptionType>
-    void CancelOperationAndThrow(std::unique_ptr<IPacketBuffer>& writerBuffer, const std::string& errorMessage)
+    void CancelOperationAndThrow(IPacketBufferPtr& writerBuffer, const std::string& errorMessage)
     {
         if (std::is_same<ExceptionType, armnn::profiling::BufferExhaustion>::value)
         {
diff --git a/src/profiling/SendTimelinePacket.hpp b/src/profiling/SendTimelinePacket.hpp
index 35ec24ffae..2f9892f314 100644
--- a/src/profiling/SendTimelinePacket.hpp
+++ b/src/profiling/SendTimelinePacket.hpp
@@ -55,7 +55,7 @@ private:
     void ReserveBuffer();
 
     IBufferManager& m_BufferManager;
-    std::unique_ptr<IPacketBuffer> m_WriteBuffer;
+    IPacketBufferPtr m_WriteBuffer;
     unsigned int m_Offset;
     unsigned int m_BufferSize;
 };
diff --git a/src/profiling/test/BufferTests.cpp b/src/profiling/test/BufferTests.cpp
index 7a06843ab3..cba209c9a2 100644
--- a/src/profiling/test/BufferTests.cpp
+++ b/src/profiling/test/BufferTests.cpp
@@ -17,7 +17,7 @@ BOOST_AUTO_TEST_SUITE(BufferTests)
 
 BOOST_AUTO_TEST_CASE(PacketBufferTest0)
 {
-    std::unique_ptr<IPacketBuffer> packetBuffer = std::make_unique<PacketBuffer>(512);
+    IPacketBufferPtr packetBuffer = std::make_unique<PacketBuffer>(512);
 
     BOOST_TEST(packetBuffer->GetSize() == 0);
 
@@ -55,7 +55,7 @@ BOOST_AUTO_TEST_CASE(PacketBufferTest0)
 
 BOOST_AUTO_TEST_CASE(PacketBufferTest1)
 {
-    std::unique_ptr<IPacketBuffer> packetBuffer = std::make_unique<PacketBuffer>(512);
+    IPacketBufferPtr packetBuffer = std::make_unique<PacketBuffer>(512);
 
     BOOST_TEST(packetBuffer->GetSize() == 0);
 
@@ -88,7 +88,7 @@ BOOST_AUTO_TEST_CASE(PacketBufferTest1)
 }
 
 BOOST_AUTO_TEST_CASE(PacketBufferReleaseTest) {
-    std::unique_ptr<IPacketBuffer> packetBuffer = std::make_unique<PacketBuffer>(512);
+    IPacketBufferPtr packetBuffer = std::make_unique<PacketBuffer>(512);
 
     BOOST_TEST(packetBuffer->GetSize() == 0);
 
@@ -107,7 +107,7 @@ BOOST_AUTO_TEST_CASE(PacketBufferReleaseTest) {
 
 BOOST_AUTO_TEST_CASE(PacketBufferCommitErrorTest)
 {
-    std::unique_ptr<IPacketBuffer> packetBuffer = std::make_unique<PacketBuffer>(8);
+    IPacketBufferPtr packetBuffer = std::make_unique<PacketBuffer>(8);
 
     // Cannot commit data bigger than the max size of the buffer
     BOOST_CHECK_THROW(packetBuffer->Commit(16);, armnn::RuntimeException);
diff --git a/src/profiling/test/SendCounterPacketTests.hpp b/src/profiling/test/SendCounterPacketTests.hpp
index 73fc39b437..d70239ef1a 100644
--- a/src/profiling/test/SendCounterPacketTests.hpp
+++ b/src/profiling/test/SendCounterPacketTests.hpp
@@ -145,7 +145,7 @@ public:
 
     ~MockBufferManager() {}
 
-    std::unique_ptr<IPacketBuffer> Reserve(unsigned int requestedSize, unsigned int& reservedSize) override
+    IPacketBufferPtr Reserve(unsigned int requestedSize, unsigned int& reservedSize) override
     {
         if (requestedSize > m_BufferSize)
         {
@@ -159,24 +159,24 @@ public:
         return std::move(m_Buffer);
     }
 
-    void Commit(std::unique_ptr<IPacketBuffer>& packetBuffer, unsigned int size) override
+    void Commit(IPacketBufferPtr& packetBuffer, unsigned int size) override
     {
         packetBuffer->Commit(size);
         m_Buffer = std::move(packetBuffer);
     }
 
-    std::unique_ptr<IPacketBuffer> GetReadableBuffer() override
+    IPacketBufferPtr GetReadableBuffer() override
     {
         return std::move(m_Buffer);
     }
 
-    void Release(std::unique_ptr<IPacketBuffer>& packetBuffer) override
+    void Release(IPacketBufferPtr& packetBuffer) override
     {
         packetBuffer->Release();
         m_Buffer = std::move(packetBuffer);
     }
 
-    void MarkRead(std::unique_ptr<IPacketBuffer>& packetBuffer) override
+    void MarkRead(IPacketBufferPtr& packetBuffer) override
     {
         packetBuffer->MarkRead();
         m_Buffer = std::move(packetBuffer);
@@ -184,14 +184,12 @@ public:
 
 private:
     unsigned int m_BufferSize;
-    std::unique_ptr<IPacketBuffer> m_Buffer;
+    IPacketBufferPtr m_Buffer;
 };
 
 class MockStreamCounterBuffer : public IBufferManager
 {
 public:
-    using IPacketBufferPtr = std::unique_ptr<IPacketBuffer>;
-
     MockStreamCounterBuffer(unsigned int maxBufferSize = 4096)
         : m_MaxBufferSize(maxBufferSize)
         , m_BufferList()
@@ -286,7 +284,7 @@ public:
     {
         std::string message("SendStreamMetaDataPacket");
         unsigned int reserved = 0;
-        std::unique_ptr<IPacketBuffer> buffer = m_BufferManager.Reserve(1024, reserved);
+        IPacketBufferPtr buffer = m_BufferManager.Reserve(1024, reserved);
         memcpy(buffer->GetWritableData(), message.c_str(), static_cast<unsigned int>(message.size()) + 1);
         m_BufferManager.Commit(buffer, reserved);
     }
@@ -295,7 +293,7 @@ public:
     {
         std::string message("SendCounterDirectoryPacket");
         unsigned int reserved = 0;
-        std::unique_ptr<IPacketBuffer> buffer = m_BufferManager.Reserve(1024, reserved);
+        IPacketBufferPtr buffer = m_BufferManager.Reserve(1024, reserved);
         memcpy(buffer->GetWritableData(), message.c_str(), static_cast<unsigned int>(message.size()) + 1);
         m_BufferManager.Commit(buffer, reserved);
     }
@@ -305,7 +303,7 @@ public:
     {
         std::string message("SendPeriodicCounterCapturePacket");
         unsigned int reserved = 0;
-        std::unique_ptr<IPacketBuffer> buffer = m_BufferManager.Reserve(1024, reserved);
+        IPacketBufferPtr buffer = m_BufferManager.Reserve(1024, reserved);
         memcpy(buffer->GetWritableData(), message.c_str(), static_cast<unsigned int>(message.size()) + 1);
         m_BufferManager.Commit(buffer, reserved);
     }
@@ -315,7 +313,7 @@ public:
     {
         std::string message("SendPeriodicCounterSelectionPacket");
         unsigned int reserved = 0;
-        std::unique_ptr<IPacketBuffer> buffer = m_BufferManager.Reserve(1024, reserved);
+        IPacketBufferPtr buffer = m_BufferManager.Reserve(1024, reserved);
         memcpy(buffer->GetWritableData(), message.c_str(), static_cast<unsigned int>(message.size()) + 1);
         m_BufferManager.Commit(buffer, reserved);
     }