From 01d1aee92275aaa77c1d5aa89829b85c91112df0 Mon Sep 17 00:00:00 2001
From: Andreas Kling <awesomekling@gmail.com>
Date: Sat, 15 Jun 2019 18:45:44 +0200
Subject: [PATCH] AK: Make RetainPtr and Retained more friendly towards const
 pointers.

Also add operator T&'s to Retained since it's nice to be able to pass them
to a function that takes a T&.
---
 AK/RetainPtr.h | 31 ++++++++++++++++++++++++++-----
 AK/Retained.h  | 23 +++++++++++++++--------
 2 files changed, 41 insertions(+), 13 deletions(-)

diff --git a/AK/RetainPtr.h b/AK/RetainPtr.h
index 0044202dee..f22b0d0f73 100644
--- a/AK/RetainPtr.h
+++ b/AK/RetainPtr.h
@@ -103,20 +103,41 @@ public:
         return *this;
     }
 
-    RetainPtr& operator=(T* ptr)
+    template<typename U>
+    RetainPtr& operator=(const Retained<U>& other)
     {
-        if (m_ptr != ptr)
+        if (m_ptr != other.ptr())
             release_if_not_null(m_ptr);
-        m_ptr = ptr;
+        m_ptr = const_cast<T*>(other.ptr());
+        ASSERT(m_ptr);
         retain_if_not_null(m_ptr);
         return *this;
     }
 
-    RetainPtr& operator=(T& object)
+    template<typename U>
+    RetainPtr& operator=(const RetainPtr<U>& other)
+    {
+        if (m_ptr != other.ptr())
+            release_if_not_null(m_ptr);
+        m_ptr = const_cast<T*>(other.ptr());
+        retain_if_not_null(m_ptr);
+        return *this;
+    }
+
+    RetainPtr& operator=(const T* ptr)
+    {
+        if (m_ptr != ptr)
+            release_if_not_null(m_ptr);
+        m_ptr = const_cast<T*>(ptr);
+        retain_if_not_null(m_ptr);
+        return *this;
+    }
+
+    RetainPtr& operator=(const T& object)
     {
         if (m_ptr != &object)
             release_if_not_null(m_ptr);
-        m_ptr = &object;
+        m_ptr = const_cast<T*>(&object);
         retain_if_not_null(m_ptr);
         return *this;
     }
diff --git a/AK/Retained.h b/AK/Retained.h
index e1aa22f8ec..a7938e0174 100644
--- a/AK/Retained.h
+++ b/AK/Retained.h
@@ -44,16 +44,10 @@ public:
     {
         m_ptr->retain();
     }
-    RETURN_TYPESTATE(unconsumed)
-    Retained(T& object)
-        : m_ptr(&object)
-    {
-        m_ptr->retain();
-    }
     template<typename U>
     RETURN_TYPESTATE(unconsumed)
-    Retained(U& object)
-        : m_ptr(&static_cast<T&>(object))
+    Retained(const U& object)
+        : m_ptr(&const_cast<T&>(static_cast<const T&>(object)))
     {
         m_ptr->retain();
     }
@@ -200,6 +194,19 @@ public:
         return m_ptr;
     }
 
+    CALLABLE_WHEN(unconsumed)
+    operator T&()
+    {
+        ASSERT(m_ptr);
+        return *m_ptr;
+    }
+    CALLABLE_WHEN(unconsumed)
+    operator const T&() const
+    {
+        ASSERT(m_ptr);
+        return *m_ptr;
+    }
+
 private:
     Retained() {}