Use std::optional in ConnThreads to allow shortening locks

This is just a refactoring changing the ConnThreads data type. The optional
value is not actually left in an unset state until the next commit.

Author: Sjors

include/mp/proxy-io.h

@@ -537,8 +537,10 @@ void ProxyServerBase<Interface, Impl>::invokeDestroy()
 //! Map from Connection to local or remote thread handle which will be used over
 //! that connection. This map will typically only contain one entry, but can
 //! contain multiple if a single thread makes IPC calls over multiple
-//! connections.
-using ConnThreads = std::map<Connection*, ProxyClient<Thread>>;
+//! connections. A std::optional value type is used to avoid the map needing to
+//! be locked while ProxyClient<Thread> objects are constructed, see
+//! ThreadContext "Synchronization note" below.
+using ConnThreads = std::map<Connection*, std::optional<ProxyClient<Thread>>>;
 using ConnThread = ConnThreads::iterator;
 
 // Retrieve ProxyClient<Thread> object associated with this connection from a

include/mp/type-context.h

@@ -47,8 +47,8 @@ void CustomBuildField(TypeList<>,
         &connection, make_request_thread)};
 
     auto context = output.init();
-    context.setThread(request_thread->second.m_client);
-    context.setCallbackThread(callback_thread->second.m_client);
+    context.setThread(request_thread->second->m_client);
+    context.setCallbackThread(callback_thread->second->m_client);
 }
 
 //! PassField override for mp.Context arguments. Return asynchronously and call

src/mp/proxy.cpp

@@ -311,8 +311,10 @@ std::tuple<ConnThread, bool> SetThread(GuardedRef<ConnThreads> threads, Connecti
     if (thread != threads.ref.end()) return {thread, false};
     thread = threads.ref.emplace(
         std::piecewise_construct, std::forward_as_tuple(connection),
-        std::forward_as_tuple(make_thread(), connection, /* destroy_connection= */ false)).first;
-    thread->second.setDisconnectCallback([threads, thread] {
+        std::forward_as_tuple()
+    ).first;
+    thread->second.emplace(make_thread(), connection, /* destroy_connection= */ false);
+    thread->second->setDisconnectCallback([threads, thread] {
         // Note: it is safe to use the `thread` iterator in this cleanup
         // function, because the iterator would only be invalid if the map entry
         // was removed, and if the map entry is removed the ProxyClient<Thread>
@@ -323,7 +325,7 @@ std::tuple<ConnThread, bool> SetThread(GuardedRef<ConnThreads> threads, Connecti
         // try to unregister this callback after connection is destroyed.
         // Remove connection pointer about to be destroyed from the map
         const Lock lock(threads.mutex);
-        thread->second.m_disconnect_cb.reset();
+        thread->second->m_disconnect_cb.reset();
         threads.ref.erase(thread);
     });
     return {thread, true};