SystemMonitor: Fallback to invalid model index if there's no main thread

In the process model we check the thread with tid=pid to figure out the
main thread of a process. This is used to construct the process view
tree with non-main threads listed as children of the process row.
However, there are sometimes circumstances where there is no main
thread, even though the process should have been removed from the
internal list by then. As a safe fallback, let's default to an invalid
model index if we can't figure out what the main thread of a process is.

Userland/Applications/SystemMonitor/ProcessModel.cpp

@@ -344,7 +344,9 @@ GUI::ModelIndex ProcessModel::index(int row, int column, GUI::ModelIndex const&
         if (row >= static_cast<int>(m_processes.size()))
             return {};
         auto corresponding_thread = m_processes[row].main_thread();
-        return create_index(row, column, corresponding_thread.ptr());
+        if (!corresponding_thread.has_value())
+            return {};
+        return create_index(row, column, corresponding_thread.release_value().ptr());
     }
     // Thread under process.
     auto const& parent_thread = *static_cast<Thread const*>(parent.internal_data());
@@ -375,8 +377,10 @@ GUI::ModelIndex ProcessModel::parent_index(GUI::ModelIndex const& index) const
         return {};
     // FIXME: We can't use first_matching here (not even a const version) because Optional cannot contain references.
     auto const& parent = thread.current_state.process;
+    if (!parent.main_thread().has_value())
+        return {};
 
-    return create_index(m_processes.find_first_index(parent).release_value(), index.column(), parent.main_thread().ptr());
+    return create_index(m_processes.find_first_index(parent).release_value(), index.column(), parent.main_thread().value().ptr());
 }
 
 Vector<GUI::ModelIndex> ProcessModel::matches(StringView searching, unsigned flags, GUI::ModelIndex const&)

Userland/Applications/SystemMonitor/ProcessModel.h

@@ -210,9 +210,9 @@ private:
             return this->pid == other.pid;
         }
 
-        NonnullRefPtr<Thread> main_thread() const
+        Optional<NonnullRefPtr<Thread>> main_thread() const
         {
-            return *threads.first_matching([this](auto const thread) { return thread->current_state.tid == pid; }).value();
+            return threads.first_matching([this](auto const thread) { return thread->current_state.tid == pid; });
         }
 
         // Return anything but the main thread; therefore, valid indices are anything up to threads.size()-1 exclusive.