Forward some extension methods which is dependent to UnityEngine.AssetBundleModule

.gitignore

@@ -160,6 +160,8 @@ src/UniTask/UniTask.*.unitypackage
 
 src/UniTask/UniTask.Linq.csproj
 
+src/UniTask/UniTask.Modules.AssetBundle.csproj
+
 src/UniTask/DOTween.Modules.csproj
 
 src/UniTask/Unity.Addressables.csproj

src/UniTask/Assets/Plugins/UniTask/Runtime/Modules.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 796ffa0906465b446ada92dd199f0092
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

src/UniTask/Assets/Plugins/UniTask/Runtime/Modules/AssetBundle.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c011199bfe2467b4f8a8a1c01c83d1e7
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

src/UniTask/Assets/Plugins/UniTask/Runtime/Modules/AssetBundle/AssetBundleAsyncExtensions.AssetBundleRequestAllAssets.cs

@@ -1,7 +1,6 @@
 #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
 
-#if UNITY_2018_4 || UNITY_2019_4_OR_NEWER
+#if (UNITY_2018_4 || UNITY_2019_4_OR_NEWER) && UNITASK_MODULES_ASSETBUNDLE
-
 using Cysharp.Threading.Tasks.Internal;
 using System;
 using System.Runtime.CompilerServices;
@@ -10,7 +9,7 @@ using UnityEngine;
 
 namespace Cysharp.Threading.Tasks
 {
-    public static partial class UnityAsyncExtensions
+    public static partial class AssetBundleAsyncExtensions
     {
         public static AssetBundleRequestAllAssetsAwaiter AwaitForAllAssets(this AssetBundleRequest asyncOperation)
         {
@@ -309,7 +308,7 @@ namespace Cysharp.Threading.Tasks
                 return pool.TryPush(this);
             }
         }
+
     }
 }
-
 #endif

src/UniTask/Assets/Plugins/UniTask/Runtime/Modules/AssetBundle/AssetBundleAsyncExtensions.cs

@@ -0,0 +1,622 @@
+#if UNITASK_MODULES_ASSETBUNDLE
+using Cysharp.Threading.Tasks.Internal;
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using UnityEngine;
+namespace Cysharp.Threading.Tasks
+{
+
+
+    public static partial class AssetBundleAsyncExtensions
+    {
+
+
+        #region AssetBundleRequest
+
+        public static AssetBundleRequestAwaiter GetAwaiter(this AssetBundleRequest asyncOperation)
+        {
+            Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
+            return new AssetBundleRequestAwaiter(asyncOperation);
+        }
+
+        public static UniTask<UnityEngine.Object> WithCancellation(this AssetBundleRequest asyncOperation, CancellationToken cancellationToken)
+        {
+            Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
+            if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled<UnityEngine.Object>(cancellationToken);
+            if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.asset);
+            return new UniTask<UnityEngine.Object>(AssetBundleRequestWithCancellationSource.Create(asyncOperation, cancellationToken, out var token), token);
+        }
+
+        public static UniTask<UnityEngine.Object> ToUniTask(this AssetBundleRequest asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
+            if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled<UnityEngine.Object>(cancellationToken);
+            if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.asset);
+            return new UniTask<UnityEngine.Object>(AssetBundleRequestConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, out var token), token);
+        }
+
+        public struct AssetBundleRequestAwaiter : ICriticalNotifyCompletion
+        {
+            AssetBundleRequest asyncOperation;
+            Action<AsyncOperation> continuationAction;
+
+            public AssetBundleRequestAwaiter(AssetBundleRequest asyncOperation)
+            {
+                this.asyncOperation = asyncOperation;
+                this.continuationAction = null;
+            }
+
+            public bool IsCompleted => asyncOperation.isDone;
+
+            public UnityEngine.Object GetResult()
+            {
+                if (continuationAction != null)
+                {
+                    asyncOperation.completed -= continuationAction;
+                    continuationAction = null;
+                    var result = asyncOperation.asset;
+                    asyncOperation = null;
+                    return result;
+                }
+                else
+                {
+                    var result = asyncOperation.asset;
+                    asyncOperation = null;
+                    return result;
+                }
+            }
+
+            public void OnCompleted(Action continuation)
+            {
+                UnsafeOnCompleted(continuation);
+            }
+
+            public void UnsafeOnCompleted(Action continuation)
+            {
+                Error.ThrowWhenContinuationIsAlreadyRegistered(continuationAction);
+                continuationAction = PooledDelegate<AsyncOperation>.Create(continuation);
+                asyncOperation.completed += continuationAction;
+            }
+        }
+
+        sealed class AssetBundleRequestWithCancellationSource : IUniTaskSource<UnityEngine.Object>, IPlayerLoopItem, ITaskPoolNode<AssetBundleRequestWithCancellationSource>
+        {
+            static TaskPool<AssetBundleRequestWithCancellationSource> pool;
+            public AssetBundleRequestWithCancellationSource NextNode { get; set; }
+
+            static AssetBundleRequestWithCancellationSource()
+            {
+                TaskPool.RegisterSizeGetter(typeof(AssetBundleRequestWithCancellationSource), () => pool.Size);
+            }
+
+            readonly Action<AsyncOperation> continuationAction;
+            AssetBundleRequest asyncOperation;
+            CancellationToken cancellationToken;
+            bool completed;
+
+            UniTaskCompletionSourceCore<UnityEngine.Object> core;
+
+            AssetBundleRequestWithCancellationSource()
+            {
+                continuationAction = Continuation;
+            }
+
+            public static IUniTaskSource<UnityEngine.Object> Create(AssetBundleRequest asyncOperation, CancellationToken cancellationToken, out short token)
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return AutoResetUniTaskCompletionSource<UnityEngine.Object>.CreateFromCanceled(cancellationToken, out token);
+                }
+
+                if (!pool.TryPop(out var result))
+                {
+                    result = new AssetBundleRequestWithCancellationSource();
+                }
+
+                result.asyncOperation = asyncOperation;
+                result.cancellationToken = cancellationToken;
+                result.completed = false;
+
+                TaskTracker.TrackActiveTask(result, 3);
+
+                PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, result);
+
+                asyncOperation.completed += result.continuationAction;
+
+                token = result.core.Version;
+                return result;
+            }
+
+            void Continuation(AsyncOperation _)
+            {
+                asyncOperation.completed -= continuationAction;
+
+                if (completed)
+                {
+                    TryReturn();
+                }
+                else
+                {
+                    completed = true;
+                    if (cancellationToken.IsCancellationRequested)
+                    {
+                        core.TrySetCanceled(cancellationToken);
+                        return;
+                    }
+
+                    core.TrySetResult(asyncOperation.asset);
+                }
+            }
+
+            public UnityEngine.Object GetResult(short token)
+            {
+                return core.GetResult(token);
+            }
+
+            void IUniTaskSource.GetResult(short token)
+            {
+                GetResult(token);
+            }
+
+            public UniTaskStatus GetStatus(short token)
+            {
+                return core.GetStatus(token);
+            }
+
+            public UniTaskStatus UnsafeGetStatus()
+            {
+                return core.UnsafeGetStatus();
+            }
+
+            public void OnCompleted(Action<object> continuation, object state, short token)
+            {
+                core.OnCompleted(continuation, state, token);
+            }
+
+            public bool MoveNext()
+            {
+                if (completed)
+                {
+                    TryReturn();
+                    return false;
+                }
+
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    completed = true;
+                    core.TrySetCanceled(cancellationToken);
+                    return false;
+                }
+
+                return true;
+            }
+
+            bool TryReturn()
+            {
+                TaskTracker.RemoveTracking(this);
+                core.Reset();
+                asyncOperation = default;
+                cancellationToken = default;
+                return pool.TryPush(this);
+            }
+        }
+
+        sealed class AssetBundleRequestConfiguredSource : IUniTaskSource<UnityEngine.Object>, IPlayerLoopItem, ITaskPoolNode<AssetBundleRequestConfiguredSource>
+        {
+            static TaskPool<AssetBundleRequestConfiguredSource> pool;
+            public AssetBundleRequestConfiguredSource NextNode { get; set; }
+
+            static AssetBundleRequestConfiguredSource()
+            {
+                TaskPool.RegisterSizeGetter(typeof(AssetBundleRequestConfiguredSource), () => pool.Size);
+            }
+
+            AssetBundleRequest asyncOperation;
+            IProgress<float> progress;
+            CancellationToken cancellationToken;
+
+            UniTaskCompletionSourceCore<UnityEngine.Object> core;
+
+            AssetBundleRequestConfiguredSource()
+            {
+
+            }
+
+            public static IUniTaskSource<UnityEngine.Object> Create(AssetBundleRequest asyncOperation, PlayerLoopTiming timing, IProgress<float> progress, CancellationToken cancellationToken, out short token)
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return AutoResetUniTaskCompletionSource<UnityEngine.Object>.CreateFromCanceled(cancellationToken, out token);
+                }
+
+                if (!pool.TryPop(out var result))
+                {
+                    result = new AssetBundleRequestConfiguredSource();
+                }
+
+                result.asyncOperation = asyncOperation;
+                result.progress = progress;
+                result.cancellationToken = cancellationToken;
+
+                TaskTracker.TrackActiveTask(result, 3);
+
+                PlayerLoopHelper.AddAction(timing, result);
+
+                token = result.core.Version;
+                return result;
+            }
+
+            public UnityEngine.Object GetResult(short token)
+            {
+                try
+                {
+                    return core.GetResult(token);
+                }
+                finally
+                {
+                    TryReturn();
+                }
+            }
+
+            void IUniTaskSource.GetResult(short token)
+            {
+                GetResult(token);
+            }
+
+            public UniTaskStatus GetStatus(short token)
+            {
+                return core.GetStatus(token);
+            }
+
+            public UniTaskStatus UnsafeGetStatus()
+            {
+                return core.UnsafeGetStatus();
+            }
+
+            public void OnCompleted(Action<object> continuation, object state, short token)
+            {
+                core.OnCompleted(continuation, state, token);
+            }
+
+            public bool MoveNext()
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    core.TrySetCanceled(cancellationToken);
+                    return false;
+                }
+
+                if (progress != null)
+                {
+                    progress.Report(asyncOperation.progress);
+                }
+
+                if (asyncOperation.isDone)
+                {
+                    core.TrySetResult(asyncOperation.asset);
+                    return false;
+                }
+
+                return true;
+            }
+
+            bool TryReturn()
+            {
+                TaskTracker.RemoveTracking(this);
+                core.Reset();
+                asyncOperation = default;
+                progress = default;
+                cancellationToken = default;
+                return pool.TryPush(this);
+            }
+        }
+
+        #endregion
+
+        #region AssetBundleCreateRequest
+
+        public static AssetBundleCreateRequestAwaiter GetAwaiter(this AssetBundleCreateRequest asyncOperation)
+        {
+            Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
+            return new AssetBundleCreateRequestAwaiter(asyncOperation);
+        }
+
+        public static UniTask<AssetBundle> WithCancellation(this AssetBundleCreateRequest asyncOperation, CancellationToken cancellationToken)
+        {
+            Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
+            if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled<AssetBundle>(cancellationToken);
+            if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.assetBundle);
+            return new UniTask<AssetBundle>(AssetBundleCreateRequestWithCancellationSource.Create(asyncOperation, cancellationToken, out var token), token);
+        }
+
+        public static UniTask<AssetBundle> ToUniTask(this AssetBundleCreateRequest asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
+            if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled<AssetBundle>(cancellationToken);
+            if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.assetBundle);
+            return new UniTask<AssetBundle>(AssetBundleCreateRequestConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, out var token), token);
+        }
+
+        public struct AssetBundleCreateRequestAwaiter : ICriticalNotifyCompletion
+        {
+            AssetBundleCreateRequest asyncOperation;
+            Action<AsyncOperation> continuationAction;
+
+            public AssetBundleCreateRequestAwaiter(AssetBundleCreateRequest asyncOperation)
+            {
+                this.asyncOperation = asyncOperation;
+                this.continuationAction = null;
+            }
+
+            public bool IsCompleted => asyncOperation.isDone;
+
+            public AssetBundle GetResult()
+            {
+                if (continuationAction != null)
+                {
+                    asyncOperation.completed -= continuationAction;
+                    continuationAction = null;
+                    var result = asyncOperation.assetBundle;
+                    asyncOperation = null;
+                    return result;
+                }
+                else
+                {
+                    var result = asyncOperation.assetBundle;
+                    asyncOperation = null;
+                    return result;
+                }
+            }
+
+            public void OnCompleted(Action continuation)
+            {
+                UnsafeOnCompleted(continuation);
+            }
+
+            public void UnsafeOnCompleted(Action continuation)
+            {
+                Error.ThrowWhenContinuationIsAlreadyRegistered(continuationAction);
+                continuationAction = PooledDelegate<AsyncOperation>.Create(continuation);
+                asyncOperation.completed += continuationAction;
+            }
+        }
+
+        sealed class AssetBundleCreateRequestWithCancellationSource : IUniTaskSource<AssetBundle>, IPlayerLoopItem, ITaskPoolNode<AssetBundleCreateRequestWithCancellationSource>
+        {
+            static TaskPool<AssetBundleCreateRequestWithCancellationSource> pool;
+            public AssetBundleCreateRequestWithCancellationSource NextNode { get; set; }
+
+            static AssetBundleCreateRequestWithCancellationSource()
+            {
+                TaskPool.RegisterSizeGetter(typeof(AssetBundleCreateRequestWithCancellationSource), () => pool.Size);
+            }
+
+            readonly Action<AsyncOperation> continuationAction;
+            AssetBundleCreateRequest asyncOperation;
+            CancellationToken cancellationToken;
+            bool completed;
+
+            UniTaskCompletionSourceCore<AssetBundle> core;
+
+            AssetBundleCreateRequestWithCancellationSource()
+            {
+                continuationAction = Continuation;
+            }
+
+            public static IUniTaskSource<AssetBundle> Create(AssetBundleCreateRequest asyncOperation, CancellationToken cancellationToken, out short token)
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return AutoResetUniTaskCompletionSource<AssetBundle>.CreateFromCanceled(cancellationToken, out token);
+                }
+
+                if (!pool.TryPop(out var result))
+                {
+                    result = new AssetBundleCreateRequestWithCancellationSource();
+                }
+
+                result.asyncOperation = asyncOperation;
+                result.cancellationToken = cancellationToken;
+                result.completed = false;
+
+                TaskTracker.TrackActiveTask(result, 3);
+
+                PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, result);
+
+                asyncOperation.completed += result.continuationAction;
+
+                token = result.core.Version;
+                return result;
+            }
+
+            void Continuation(AsyncOperation _)
+            {
+                asyncOperation.completed -= continuationAction;
+
+                if (completed)
+                {
+                    TryReturn();
+                }
+                else
+                {
+                    completed = true;
+                    if (cancellationToken.IsCancellationRequested)
+                    {
+                        core.TrySetCanceled(cancellationToken);
+                        return;
+                    }
+
+                    core.TrySetResult(asyncOperation.assetBundle);
+                }
+            }
+
+            public AssetBundle GetResult(short token)
+            {
+                return core.GetResult(token);
+            }
+
+            void IUniTaskSource.GetResult(short token)
+            {
+                GetResult(token);
+            }
+
+            public UniTaskStatus GetStatus(short token)
+            {
+                return core.GetStatus(token);
+            }
+
+            public UniTaskStatus UnsafeGetStatus()
+            {
+                return core.UnsafeGetStatus();
+            }
+
+            public void OnCompleted(Action<object> continuation, object state, short token)
+            {
+                core.OnCompleted(continuation, state, token);
+            }
+
+            public bool MoveNext()
+            {
+                if (completed)
+                {
+                    TryReturn();
+                    return false;
+                }
+
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    completed = true;
+                    core.TrySetCanceled(cancellationToken);
+                    return false;
+                }
+
+                return true;
+            }
+
+            bool TryReturn()
+            {
+                TaskTracker.RemoveTracking(this);
+                core.Reset();
+                asyncOperation = default;
+                cancellationToken = default;
+                return pool.TryPush(this);
+            }
+        }
+
+        sealed class AssetBundleCreateRequestConfiguredSource : IUniTaskSource<AssetBundle>, IPlayerLoopItem, ITaskPoolNode<AssetBundleCreateRequestConfiguredSource>
+        {
+            static TaskPool<AssetBundleCreateRequestConfiguredSource> pool;
+            public AssetBundleCreateRequestConfiguredSource NextNode { get; set; }
+
+            static AssetBundleCreateRequestConfiguredSource()
+            {
+                TaskPool.RegisterSizeGetter(typeof(AssetBundleCreateRequestConfiguredSource), () => pool.Size);
+            }
+
+            AssetBundleCreateRequest asyncOperation;
+            IProgress<float> progress;
+            CancellationToken cancellationToken;
+
+            UniTaskCompletionSourceCore<AssetBundle> core;
+
+            AssetBundleCreateRequestConfiguredSource()
+            {
+
+            }
+
+            public static IUniTaskSource<AssetBundle> Create(AssetBundleCreateRequest asyncOperation, PlayerLoopTiming timing, IProgress<float> progress, CancellationToken cancellationToken, out short token)
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return AutoResetUniTaskCompletionSource<AssetBundle>.CreateFromCanceled(cancellationToken, out token);
+                }
+
+                if (!pool.TryPop(out var result))
+                {
+                    result = new AssetBundleCreateRequestConfiguredSource();
+                }
+
+                result.asyncOperation = asyncOperation;
+                result.progress = progress;
+                result.cancellationToken = cancellationToken;
+
+                TaskTracker.TrackActiveTask(result, 3);
+
+                PlayerLoopHelper.AddAction(timing, result);
+
+                token = result.core.Version;
+                return result;
+            }
+
+            public AssetBundle GetResult(short token)
+            {
+                try
+                {
+                    return core.GetResult(token);
+                }
+                finally
+                {
+                    TryReturn();
+                }
+            }
+
+            void IUniTaskSource.GetResult(short token)
+            {
+                GetResult(token);
+            }
+
+            public UniTaskStatus GetStatus(short token)
+            {
+                return core.GetStatus(token);
+            }
+
+            public UniTaskStatus UnsafeGetStatus()
+            {
+                return core.UnsafeGetStatus();
+            }
+
+            public void OnCompleted(Action<object> continuation, object state, short token)
+            {
+                core.OnCompleted(continuation, state, token);
+            }
+
+            public bool MoveNext()
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    core.TrySetCanceled(cancellationToken);
+                    return false;
+                }
+
+                if (progress != null)
+                {
+                    progress.Report(asyncOperation.progress);
+                }
+
+                if (asyncOperation.isDone)
+                {
+                    core.TrySetResult(asyncOperation.assetBundle);
+                    return false;
+                }
+
+                return true;
+            }
+
+            bool TryReturn()
+            {
+                TaskTracker.RemoveTracking(this);
+                core.Reset();
+                asyncOperation = default;
+                progress = default;
+                cancellationToken = default;
+                return pool.TryPush(this);
+            }
+        }
+
+        #endregion
+
+
+    }
+}
+#endif

src/UniTask/Assets/Plugins/UniTask/Runtime/Modules/AssetBundle/AssetBundleAsyncExtensions.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 31079e7527b74f947b26df8b2626f36e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

src/UniTask/Assets/Plugins/UniTask/Runtime/Modules/AssetBundle/UniTask.Modules.AssetBundle.asmdef

@@ -0,0 +1,21 @@
+{
+    "name": "UniTask.Modules.AssetBundle",
+    "references": [
+        "UniTask"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [
+        {
+            "name": "com.unity.modules.assetbundle",
+            "expression": "",
+            "define": "UNITASK_MODULES_ASSETBUNDLE"
+        }
+    ],
+    "noEngineReferences": false
+}

src/UniTask/Assets/Plugins/UniTask/Runtime/Modules/AssetBundle/UniTask.Modules.AssetBundle.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: c0a8c2dd3ebbbd04b860af0504f5d7b8
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.cs

@@ -605,610 +605,6 @@ namespace Cysharp.Threading.Tasks
 
         #endregion
 
-        #region AssetBundleRequest
-
-        public static AssetBundleRequestAwaiter GetAwaiter(this AssetBundleRequest asyncOperation)
-        {
-            Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
-            return new AssetBundleRequestAwaiter(asyncOperation);
-        }
-
-        public static UniTask<UnityEngine.Object> WithCancellation(this AssetBundleRequest asyncOperation, CancellationToken cancellationToken)
-        {
-            Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
-            if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled<UnityEngine.Object>(cancellationToken);
-            if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.asset);
-            return new UniTask<UnityEngine.Object>(AssetBundleRequestWithCancellationSource.Create(asyncOperation, cancellationToken, out var token), token);
-        }
-
-        public static UniTask<UnityEngine.Object> ToUniTask(this AssetBundleRequest asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
-            if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled<UnityEngine.Object>(cancellationToken);
-            if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.asset);
-            return new UniTask<UnityEngine.Object>(AssetBundleRequestConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, out var token), token);
-        }
-
-        public struct AssetBundleRequestAwaiter : ICriticalNotifyCompletion
-        {
-            AssetBundleRequest asyncOperation;
-            Action<AsyncOperation> continuationAction;
-
-            public AssetBundleRequestAwaiter(AssetBundleRequest asyncOperation)
-            {
-                this.asyncOperation = asyncOperation;
-                this.continuationAction = null;
-            }
-
-            public bool IsCompleted => asyncOperation.isDone;
-
-            public UnityEngine.Object GetResult()
-            {
-                if (continuationAction != null)
-                {
-                    asyncOperation.completed -= continuationAction;
-                    continuationAction = null;
-                    var result = asyncOperation.asset;
-                    asyncOperation = null;
-                    return result;
-                }
-                else
-                {
-                    var result = asyncOperation.asset;
-                    asyncOperation = null;
-                    return result;
-                }
-            }
-
-            public void OnCompleted(Action continuation)
-            {
-                UnsafeOnCompleted(continuation);
-            }
-
-            public void UnsafeOnCompleted(Action continuation)
-            {
-                Error.ThrowWhenContinuationIsAlreadyRegistered(continuationAction);
-                continuationAction = PooledDelegate<AsyncOperation>.Create(continuation);
-                asyncOperation.completed += continuationAction;
-            }
-        }
-
-        sealed class AssetBundleRequestWithCancellationSource : IUniTaskSource<UnityEngine.Object>, IPlayerLoopItem, ITaskPoolNode<AssetBundleRequestWithCancellationSource>
-        {
-            static TaskPool<AssetBundleRequestWithCancellationSource> pool;
-            public AssetBundleRequestWithCancellationSource NextNode { get; set; }
-
-            static AssetBundleRequestWithCancellationSource()
-            {
-                TaskPool.RegisterSizeGetter(typeof(AssetBundleRequestWithCancellationSource), () => pool.Size);
-            }
-
-            readonly Action<AsyncOperation> continuationAction;
-            AssetBundleRequest asyncOperation;
-            CancellationToken cancellationToken;
-            bool completed;
-
-            UniTaskCompletionSourceCore<UnityEngine.Object> core;
-
-            AssetBundleRequestWithCancellationSource()
-            {
-                continuationAction = Continuation;
-            }
-
-            public static IUniTaskSource<UnityEngine.Object> Create(AssetBundleRequest asyncOperation, CancellationToken cancellationToken, out short token)
-            {
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    return AutoResetUniTaskCompletionSource<UnityEngine.Object>.CreateFromCanceled(cancellationToken, out token);
-                }
-
-                if (!pool.TryPop(out var result))
-                {
-                    result = new AssetBundleRequestWithCancellationSource();
-                }
-
-                result.asyncOperation = asyncOperation;
-                result.cancellationToken = cancellationToken;
-                result.completed = false;
-
-                TaskTracker.TrackActiveTask(result, 3);
-
-                PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, result);
-
-                asyncOperation.completed += result.continuationAction;
-
-                token = result.core.Version;
-                return result;
-            }
-
-            void Continuation(AsyncOperation _)
-            {
-                asyncOperation.completed -= continuationAction;
-
-                if (completed)
-                {
-                    TryReturn();
-                }
-                else
-                {
-                    completed = true;
-                    if (cancellationToken.IsCancellationRequested)
-                    {
-                        core.TrySetCanceled(cancellationToken);
-                        return;
-                    }
-
-                    core.TrySetResult(asyncOperation.asset);
-                }
-            }
-
-            public UnityEngine.Object GetResult(short token)
-            {
-                return core.GetResult(token);
-            }
-
-            void IUniTaskSource.GetResult(short token)
-            {
-                GetResult(token);
-            }
-
-            public UniTaskStatus GetStatus(short token)
-            {
-                return core.GetStatus(token);
-            }
-
-            public UniTaskStatus UnsafeGetStatus()
-            {
-                return core.UnsafeGetStatus();
-            }
-
-            public void OnCompleted(Action<object> continuation, object state, short token)
-            {
-                core.OnCompleted(continuation, state, token);
-            }
-
-            public bool MoveNext()
-            {   
-                if (completed)
-                {
-                    TryReturn();
-                    return false;
-                }
-
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    completed = true;
-                    core.TrySetCanceled(cancellationToken);
-                    return false;
-                }
-
-                return true;
-            }
-
-            bool TryReturn()
-            {
-                TaskTracker.RemoveTracking(this);
-                core.Reset();
-                asyncOperation = default;
-                cancellationToken = default;
-                return pool.TryPush(this);
-            }
-        }
-
-        sealed class AssetBundleRequestConfiguredSource : IUniTaskSource<UnityEngine.Object>, IPlayerLoopItem, ITaskPoolNode<AssetBundleRequestConfiguredSource>
-        {
-            static TaskPool<AssetBundleRequestConfiguredSource> pool;
-            public AssetBundleRequestConfiguredSource NextNode { get; set; }
-
-            static AssetBundleRequestConfiguredSource()
-            {
-                TaskPool.RegisterSizeGetter(typeof(AssetBundleRequestConfiguredSource), () => pool.Size);
-            }
-
-            AssetBundleRequest asyncOperation;
-            IProgress<float> progress;
-            CancellationToken cancellationToken;
-
-            UniTaskCompletionSourceCore<UnityEngine.Object> core;
-
-            AssetBundleRequestConfiguredSource()
-            {
-
-            }
-
-            public static IUniTaskSource<UnityEngine.Object> Create(AssetBundleRequest asyncOperation, PlayerLoopTiming timing, IProgress<float> progress, CancellationToken cancellationToken, out short token)
-            {
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    return AutoResetUniTaskCompletionSource<UnityEngine.Object>.CreateFromCanceled(cancellationToken, out token);
-                }
-
-                if (!pool.TryPop(out var result))
-                {
-                    result = new AssetBundleRequestConfiguredSource();
-                }
-
-                result.asyncOperation = asyncOperation;
-                result.progress = progress;
-                result.cancellationToken = cancellationToken;
-
-                TaskTracker.TrackActiveTask(result, 3);
-
-                PlayerLoopHelper.AddAction(timing, result);
-
-                token = result.core.Version;
-                return result;
-            }
-
-            public UnityEngine.Object GetResult(short token)
-            {
-                try
-                {
-                    return core.GetResult(token);
-                }
-                finally
-                {
-                    TryReturn();
-                }
-            }
-
-            void IUniTaskSource.GetResult(short token)
-            {
-                GetResult(token);
-            }
-
-            public UniTaskStatus GetStatus(short token)
-            {
-                return core.GetStatus(token);
-            }
-
-            public UniTaskStatus UnsafeGetStatus()
-            {
-                return core.UnsafeGetStatus();
-            }
-
-            public void OnCompleted(Action<object> continuation, object state, short token)
-            {
-                core.OnCompleted(continuation, state, token);
-            }
-
-            public bool MoveNext()
-            {
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    core.TrySetCanceled(cancellationToken);
-                    return false;
-                }
-
-                if (progress != null)
-                {
-                    progress.Report(asyncOperation.progress);
-                }
-
-                if (asyncOperation.isDone)
-                {
-                    core.TrySetResult(asyncOperation.asset);
-                    return false;
-                }
-
-                return true;
-            }
-
-            bool TryReturn()
-            {
-                TaskTracker.RemoveTracking(this);
-                core.Reset();
-                asyncOperation = default;
-                progress = default;
-                cancellationToken = default;
-                return pool.TryPush(this);
-            }
-        }
-
-        #endregion
-
-        #region AssetBundleCreateRequest
-
-        public static AssetBundleCreateRequestAwaiter GetAwaiter(this AssetBundleCreateRequest asyncOperation)
-        {
-            Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
-            return new AssetBundleCreateRequestAwaiter(asyncOperation);
-        }
-
-        public static UniTask<AssetBundle> WithCancellation(this AssetBundleCreateRequest asyncOperation, CancellationToken cancellationToken)
-        {
-            Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
-            if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled<AssetBundle>(cancellationToken);
-            if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.assetBundle);
-            return new UniTask<AssetBundle>(AssetBundleCreateRequestWithCancellationSource.Create(asyncOperation, cancellationToken, out var token), token);
-        }
-
-        public static UniTask<AssetBundle> ToUniTask(this AssetBundleCreateRequest asyncOperation, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
-        {
-            Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
-            if (cancellationToken.IsCancellationRequested) return UniTask.FromCanceled<AssetBundle>(cancellationToken);
-            if (asyncOperation.isDone) return UniTask.FromResult(asyncOperation.assetBundle);
-            return new UniTask<AssetBundle>(AssetBundleCreateRequestConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, out var token), token);
-        }
-
-        public struct AssetBundleCreateRequestAwaiter : ICriticalNotifyCompletion
-        {
-            AssetBundleCreateRequest asyncOperation;
-            Action<AsyncOperation> continuationAction;
-
-            public AssetBundleCreateRequestAwaiter(AssetBundleCreateRequest asyncOperation)
-            {
-                this.asyncOperation = asyncOperation;
-                this.continuationAction = null;
-            }
-
-            public bool IsCompleted => asyncOperation.isDone;
-
-            public AssetBundle GetResult()
-            {
-                if (continuationAction != null)
-                {
-                    asyncOperation.completed -= continuationAction;
-                    continuationAction = null;
-                    var result = asyncOperation.assetBundle;
-                    asyncOperation = null;
-                    return result;
-                }
-                else
-                {
-                    var result = asyncOperation.assetBundle;
-                    asyncOperation = null;
-                    return result;
-                }
-            }
-
-            public void OnCompleted(Action continuation)
-            {
-                UnsafeOnCompleted(continuation);
-            }
-
-            public void UnsafeOnCompleted(Action continuation)
-            {
-                Error.ThrowWhenContinuationIsAlreadyRegistered(continuationAction);
-                continuationAction = PooledDelegate<AsyncOperation>.Create(continuation);
-                asyncOperation.completed += continuationAction;
-            }
-        }
-
-        sealed class AssetBundleCreateRequestWithCancellationSource : IUniTaskSource<AssetBundle>, IPlayerLoopItem, ITaskPoolNode<AssetBundleCreateRequestWithCancellationSource>
-        {
-            static TaskPool<AssetBundleCreateRequestWithCancellationSource> pool;
-            public AssetBundleCreateRequestWithCancellationSource NextNode { get; set; }
-
-            static AssetBundleCreateRequestWithCancellationSource()
-            {
-                TaskPool.RegisterSizeGetter(typeof(AssetBundleCreateRequestWithCancellationSource), () => pool.Size);
-            }
-
-            readonly Action<AsyncOperation> continuationAction;
-            AssetBundleCreateRequest asyncOperation;
-            CancellationToken cancellationToken;
-            bool completed;
-
-            UniTaskCompletionSourceCore<AssetBundle> core;
-
-            AssetBundleCreateRequestWithCancellationSource()
-            {
-                continuationAction = Continuation;
-            }
-
-            public static IUniTaskSource<AssetBundle> Create(AssetBundleCreateRequest asyncOperation, CancellationToken cancellationToken, out short token)
-            {
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    return AutoResetUniTaskCompletionSource<AssetBundle>.CreateFromCanceled(cancellationToken, out token);
-                }
-
-                if (!pool.TryPop(out var result))
-                {
-                    result = new AssetBundleCreateRequestWithCancellationSource();
-                }
-
-                result.asyncOperation = asyncOperation;
-                result.cancellationToken = cancellationToken;
-                result.completed = false;
-
-                TaskTracker.TrackActiveTask(result, 3);
-
-                PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, result);
-
-                asyncOperation.completed += result.continuationAction;
-
-                token = result.core.Version;
-                return result;
-            }
-
-            void Continuation(AsyncOperation _)
-            {
-                asyncOperation.completed -= continuationAction;
-
-                if (completed)
-                {
-                    TryReturn();
-                }
-                else
-                {
-                    completed = true;
-                    if (cancellationToken.IsCancellationRequested)
-                    {
-                        core.TrySetCanceled(cancellationToken);
-                        return;
-                    }
-
-                    core.TrySetResult(asyncOperation.assetBundle);
-                }
-            }
-
-            public AssetBundle GetResult(short token)
-            {
-                return core.GetResult(token);
-            }
-
-            void IUniTaskSource.GetResult(short token)
-            {
-                GetResult(token);
-            }
-
-            public UniTaskStatus GetStatus(short token)
-            {
-                return core.GetStatus(token);
-            }
-
-            public UniTaskStatus UnsafeGetStatus()
-            {
-                return core.UnsafeGetStatus();
-            }
-
-            public void OnCompleted(Action<object> continuation, object state, short token)
-            {
-                core.OnCompleted(continuation, state, token);
-            }
-
-            public bool MoveNext()
-            {   
-                if (completed)
-                {
-                    TryReturn();
-                    return false;
-                }
-
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    completed = true;
-                    core.TrySetCanceled(cancellationToken);
-                    return false;
-                }
-
-                return true;
-            }
-
-            bool TryReturn()
-            {
-                TaskTracker.RemoveTracking(this);
-                core.Reset();
-                asyncOperation = default;
-                cancellationToken = default;
-                return pool.TryPush(this);
-            }
-        }
-
-        sealed class AssetBundleCreateRequestConfiguredSource : IUniTaskSource<AssetBundle>, IPlayerLoopItem, ITaskPoolNode<AssetBundleCreateRequestConfiguredSource>
-        {
-            static TaskPool<AssetBundleCreateRequestConfiguredSource> pool;
-            public AssetBundleCreateRequestConfiguredSource NextNode { get; set; }
-
-            static AssetBundleCreateRequestConfiguredSource()
-            {
-                TaskPool.RegisterSizeGetter(typeof(AssetBundleCreateRequestConfiguredSource), () => pool.Size);
-            }
-
-            AssetBundleCreateRequest asyncOperation;
-            IProgress<float> progress;
-            CancellationToken cancellationToken;
-
-            UniTaskCompletionSourceCore<AssetBundle> core;
-
-            AssetBundleCreateRequestConfiguredSource()
-            {
-
-            }
-
-            public static IUniTaskSource<AssetBundle> Create(AssetBundleCreateRequest asyncOperation, PlayerLoopTiming timing, IProgress<float> progress, CancellationToken cancellationToken, out short token)
-            {
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    return AutoResetUniTaskCompletionSource<AssetBundle>.CreateFromCanceled(cancellationToken, out token);
-                }
-
-                if (!pool.TryPop(out var result))
-                {
-                    result = new AssetBundleCreateRequestConfiguredSource();
-                }
-
-                result.asyncOperation = asyncOperation;
-                result.progress = progress;
-                result.cancellationToken = cancellationToken;
-
-                TaskTracker.TrackActiveTask(result, 3);
-
-                PlayerLoopHelper.AddAction(timing, result);
-
-                token = result.core.Version;
-                return result;
-            }
-
-            public AssetBundle GetResult(short token)
-            {
-                try
-                {
-                    return core.GetResult(token);
-                }
-                finally
-                {
-                    TryReturn();
-                }
-            }
-
-            void IUniTaskSource.GetResult(short token)
-            {
-                GetResult(token);
-            }
-
-            public UniTaskStatus GetStatus(short token)
-            {
-                return core.GetStatus(token);
-            }
-
-            public UniTaskStatus UnsafeGetStatus()
-            {
-                return core.UnsafeGetStatus();
-            }
-
-            public void OnCompleted(Action<object> continuation, object state, short token)
-            {
-                core.OnCompleted(continuation, state, token);
-            }
-
-            public bool MoveNext()
-            {
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    core.TrySetCanceled(cancellationToken);
-                    return false;
-                }
-
-                if (progress != null)
-                {
-                    progress.Report(asyncOperation.progress);
-                }
-
-                if (asyncOperation.isDone)
-                {
-                    core.TrySetResult(asyncOperation.assetBundle);
-                    return false;
-                }
-
-                return true;
-            }
-
-            bool TryReturn()
-            {
-                TaskTracker.RemoveTracking(this);
-                core.Reset();
-                asyncOperation = default;
-                progress = default;
-                cancellationToken = default;
-                return pool.TryPush(this);
-            }
-        }
-
-        #endregion
-
 #if ENABLE_UNITYWEBREQUEST
         #region UnityWebRequestAsyncOperation
 

src/UniTask/Assets/Plugins/UniTask/Runtime/_InternalVisibleTo.cs

@@ -1,6 +1,7 @@
 using System.Runtime.CompilerServices;
 
 [assembly: InternalsVisibleTo("UniTask.Linq")]
+[assembly: InternalsVisibleTo("UniTask.Modules.AssetBundle")]
 [assembly: InternalsVisibleTo("UniTask.Addressables")]
 [assembly: InternalsVisibleTo("UniTask.DOTween")]
 [assembly: InternalsVisibleTo("UniTask.TextMeshPro")]