Fix data race in JavaDataViewerProxy::GetCurrentEndpoint

IDataViewer returns the endpoint by const reference, so the referent must
outlive the call and must not be mutated while a caller holds it. The
proxy updated a shared member under a mutex and then returned a reference
to it, releasing the lock on return: two concurrent callers could read and
write the same string at once, so the mutex gave no protection.

Use a thread_local buffer instead, which gives each calling thread its own
storage and removes the need for the lock. Behaviour is unchanged: the
endpoint is still read from Java on every call, so a viewer that changes
endpoints still reports the current one.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: kdhawaniya

lib/jni/JavaDataViewerProxy.cpp

@@ -168,23 +168,31 @@ namespace MAT_NS_BEGIN
 
     const std::string& JavaDataViewerProxy::GetCurrentEndpoint() const noexcept
     {
-        std::lock_guard<std::mutex> lock(m_endpointMutex);
+        // IDataViewer returns the endpoint by reference, so the referent has to outlive the
+        // call and must not be mutated by a concurrent caller. A thread_local buffer gives
+        // each calling thread its own storage; a shared member guarded by a mutex would not,
+        // because the lock is released before the caller reads the reference.
+        static thread_local std::string currentEndpoint;
+
         bool attached = false;
         auto env = GetEnv(attached);
-        if (env != nullptr)
+        if (env == nullptr)
         {
-            std::string endpoint;
-            if (ReadString(env, m_getCurrentEndpoint, endpoint))
-            {
-                m_currentEndpoint = std::move(endpoint);
-            }
-            else
-            {
-                m_currentEndpoint.clear();
-            }
-            DetachIfNeeded(attached);
+            currentEndpoint.clear();
+            return currentEndpoint;
+        }
+
+        std::string endpoint;
+        if (ReadString(env, m_getCurrentEndpoint, endpoint))
+        {
+            currentEndpoint = std::move(endpoint);
         }
-        return m_currentEndpoint;
+        else
+        {
+            currentEndpoint.clear();
+        }
+        DetachIfNeeded(attached);
+        return currentEndpoint;
     }
 
     JNIEnv* JavaDataViewerProxy::GetEnv(bool& attached) const noexcept

lib/jni/JavaDataViewerProxy.hpp

@@ -9,7 +9,6 @@
 
 #include <jni.h>
 #include <memory>
-#include <mutex>
 #include <string>
 
 namespace MAT_NS_BEGIN
@@ -41,8 +40,6 @@ namespace MAT_NS_BEGIN
         jmethodID m_isTransmissionEnabled = nullptr;
         jmethodID m_getCurrentEndpoint = nullptr;
         std::string m_name;
-        mutable std::mutex m_endpointMutex;
-        mutable std::string m_currentEndpoint;
     };
 
 } MAT_NS_END