Microsoft GDK Package: Questions about DispatchTaskQueue in In Game Store Sample

Hello,

Windows computer,
Unity 2021.3.43f1
Windows SDK 10.0.22621.3233 (10.1.22621.3233 written below)
Windows SDK 10.0.26100.1 (10.1.26100.1 written below)

We are added com.unity.microsoft.gdk 1.1.0 to our project.
In Game Store (Assets/Samples/Microsoft GDK API/1.1.0/In Game Store/Scripts/GDKGameRuntime.cs) uses coroutine for dispatching events:

		private static IEnumerator DispatchGDKTaskQueue()
		{
			while (true)
			{
#if MS_STORE_PC_BUILD
				SDK.XTaskQueueDispatch(0);
#endif
				yield return null;
			}
		}

Then we upgraded to version 1.2.3, in which (for Unity pre-6) async-await utilized for the same task:

        private async void Start()
        {
            // SDK.XTaskQueueDispatch(0) needs to be call to pump GDK events.
            // It is possible to call the function on the main thread (i.e. update method)
            // but it can create stuttering, since some GDK actions can block the thread.
            // The recommended approach is to run XTaskQueueDispatch on another thread.
            // But keep in mind that most Unity API are not thread safe and can cause crashes
            // and other problems when accessing Unity functions.
            m_CancellationTokenSource = new CancellationTokenSource();
            await DispatchTaskQueue(m_CancellationTokenSource.Token);
        }

        private static async Task DispatchTaskQueue(CancellationToken token)
        {
            while (!token.IsCancellationRequested)
            {
                SDK.XTaskQueueDispatch(0);
                await Task.Delay(32, token);
            }

            Debug.Log("Closing default XTaskQueue.");
            SDK.CloseDefaultXTaskQueue();
        }

We are little confused with

// It is possible to call the function on the main thread (i.e. update method)

comment which present on both versions.
Do we understand correctly that in both versions (coroutine and async-await) SDK.XTaskQueueDispatch(0) are happens on main thread?
(As we know default synchronization context in Unity run continuations on main thread, but we may be wrong)

Do we need to provide implementation that make dispatching in secondary thread? Or this is ok to dispatch on main thread?