Kernel: Make Thread::Blocker::m_thread a NonnullRefPtr<Thread>

There's no harm in the blocker always knowing which thread it originated
from. It also simplifies some logic since we don't need to think about
it ever being null.

Kernel/Thread.h

@@ -346,7 +346,10 @@ public:
         BlockResult end_blocking(Badge<Thread>, bool);
 
     protected:
-        Blocker() { }
+        Blocker()
+            : m_thread(*Thread::current())
+        {
+        }
 
         void do_set_interrupted_by_death()
         {
@@ -371,19 +374,14 @@ public:
         }
         void unblock_from_blocker()
         {
-            RefPtr<Thread> thread;
-
             {
                 SpinlockLocker lock(m_lock);
-                if (m_is_blocking) {
-                    m_is_blocking = false;
-                    VERIFY(m_blocked_thread);
-                    thread = m_blocked_thread;
-                }
+                if (!m_is_blocking)
+                    return;
+                m_is_blocking = false;
             }
 
-            if (thread)
-                thread->unblock_from_blocker(*this);
+            m_thread->unblock_from_blocker(*this);
         }
 
         bool add_to_blocker_set(BlockerSet&, void* = nullptr);
@@ -393,7 +391,7 @@ public:
 
     private:
         BlockerSet* m_blocker_set { nullptr };
-        Thread* m_blocked_thread { nullptr };
+        NonnullRefPtr<Thread> m_thread;
         u8 m_was_interrupted_by_signal { 0 };
         bool m_is_blocking { false };
         bool m_was_interrupted_by_death { false };

Kernel/ThreadBlockers.cpp

@@ -49,8 +49,6 @@ void Thread::Blocker::begin_blocking(Badge<Thread>)
 {
     SpinlockLocker lock(m_lock);
     VERIFY(!m_is_blocking);
-    VERIFY(!m_blocked_thread);
-    m_blocked_thread = Thread::current();
     m_is_blocking = true;
 }
 
@@ -60,9 +58,8 @@ auto Thread::Blocker::end_blocking(Badge<Thread>, bool did_timeout) -> BlockResu
     // if m_is_blocking is false here, some thread forced to
     // unblock us when we get here. This is only called from the
     // thread that was blocked.
-    VERIFY(Thread::current() == m_blocked_thread);
+    VERIFY(Thread::current() == m_thread);
     m_is_blocking = false;
-    m_blocked_thread = nullptr;
 
     was_unblocked(did_timeout);
     return block_result();