Make the available targets an async dictionary (#2281)

kblok · web-flow · commit 2e21ecd294ce · 2023-08-15T10:52:59.000-03:00
* Make the available targets an async dictionary

* Ignore one test
diff --git a/lib/PuppeteerSharp.Tests/HeadfulTests/HeadfulTests.cs b/lib/PuppeteerSharp.Tests/HeadfulTests/HeadfulTests.cs
@@ -40,7 +40,7 @@ public async Task BackgroundPageTargetTypeShouldBeAvailable()
         }
 
         [PuppeteerTest("headful.spec.ts", "HEADFUL", "target.page() should return a background_page")]
-        [Skip(SkipAttribute.Targets.Firefox)]
+        [Ignore("Marked as Fail/Pass upstream")]
         public async Task TargetPageShouldReturnABackgroundPage()
         {
             await using (var browserWithExtension = await Puppeteer.LaunchAsync(
diff --git a/lib/PuppeteerSharp/Browser.cs b/lib/PuppeteerSharp/Browser.cs
@@ -147,7 +147,8 @@ public bool IsClosed
         public Task<IPage> NewPageAsync() => _defaultContext.NewPageAsync();
 
         /// <inheritdoc/>
-        public ITarget[] Targets() => TargetManager.GetAvailableTargets().Values.ToArray();
+        public ITarget[] Targets()
+            => TargetManager.GetAvailableTargets().InnerDictionary.Values.ToArray();
 
         /// <inheritdoc/>
         public async Task<IBrowserContext> CreateIncognitoBrowserContextAsync()
@@ -317,7 +318,7 @@ internal async Task<IPage> CreatePageInContextAsync(string contextId)
 
             var targetId = (await Connection.SendAsync<TargetCreateTargetResponse>("Target.createTarget", createTargetRequest)
                 .ConfigureAwait(false)).TargetId;
-            var target = TargetManager.GetAvailableTargets()[targetId];
+            var target = await TargetManager.GetAvailableTargets().GetItemAsync(targetId).ConfigureAwait(false);
             await target.InitializedTask.ConfigureAwait(false);
             return await target.PageAsync().ConfigureAwait(false);
         }
diff --git a/lib/PuppeteerSharp/ChromeTargetManager.cs b/lib/PuppeteerSharp/ChromeTargetManager.cs
@@ -19,7 +19,8 @@ internal class ChromeTargetManager : ITargetManager
         private readonly Func<TargetInfo, CDPSession, Target> _targetFactoryFunc;
         private readonly Func<TargetInfo, bool> _targetFilterFunc;
         private readonly ILogger<ChromeTargetManager> _logger;
-        private readonly ConcurrentDictionary<string, Target> _attachedTargetsByTargetId = new();
+        private readonly ConcurrentDictionary<string, Target> _availableTargetsByTargetIdDictionary = new();
+        private readonly AsyncDictionaryHelper<string, Target> _attachedTargetsByTargetId;
         private readonly ConcurrentDictionary<string, Target> _attachedTargetsBySessionId = new();
         private readonly ConcurrentDictionary<string, TargetInfo> _discoveredTargetsByTargetId = new();
         private readonly ConcurrentDictionary<ICDPConnection, List<TargetInterceptor>> _targetInterceptors = new();
@@ -36,6 +37,7 @@ public ChromeTargetManager(
             Func<TargetInfo, bool> targetFilterFunc,
             int targetDiscoveryTimeout = 0)
         {
+            _attachedTargetsByTargetId = new AsyncDictionaryHelper<string, Target>(_availableTargetsByTargetIdDictionary, "Target {0} not found");
             _connection = connection;
             _targetFilterFunc = targetFilterFunc;
             _targetFactoryFunc = targetFactoryFunc;
@@ -86,7 +88,7 @@ public ChromeTargetManager(
 
         public event EventHandler<TargetChangedArgs> TargetDiscovered;
 
-        public ConcurrentDictionary<string, Target> GetAvailableTargets() => _attachedTargetsByTargetId;
+        public AsyncDictionaryHelper<string, Target> GetAvailableTargets() => _attachedTargetsByTargetId;
 
         public async Task InitializeAsync()
         {
@@ -112,11 +114,7 @@ public void AddTargetInterceptor(CDPSession session, TargetInterceptor intercept
         public void RemoveTargetInterceptor(CDPSession session, TargetInterceptor interceptor)
         {
             _targetInterceptors.TryGetValue(session, out var interceptors);
-
-            if (interceptors != null)
-            {
-                interceptors.Remove(interceptor);
-            }
+            interceptors?.Remove(interceptor);
         }
 
         private void StoreExistingTargetsForInit()
@@ -190,13 +188,13 @@ private void OnTargetCreated(TargetCreatedResponse e)
 
             if (e.TargetInfo.Type == TargetType.Browser && e.TargetInfo.Attached)
             {
-                if (_attachedTargetsByTargetId.ContainsKey(e.TargetInfo.TargetId))
+                if (_availableTargetsByTargetIdDictionary.ContainsKey(e.TargetInfo.TargetId))
                 {
                     return;
                 }
 
                 var target = _targetFactoryFunc(e.TargetInfo, null);
-                _attachedTargetsByTargetId[e.TargetInfo.TargetId] = target;
+                _attachedTargetsByTargetId.AddItem(e.TargetInfo.TargetId, target);
             }
         }
 
@@ -206,7 +204,7 @@ private async void OnTargetDestroyed(TargetDestroyedResponse e)
             await EnsureTargetsIdsForInit().ConfigureAwait(false);
             FinishInitializationIfReady(e.TargetId);
 
-            if (targetInfo?.Type == TargetType.ServiceWorker && _attachedTargetsByTargetId.TryRemove(e.TargetId, out var target))
+            if (targetInfo?.Type == TargetType.ServiceWorker && _availableTargetsByTargetIdDictionary.TryRemove(e.TargetId, out var target))
             {
                 TargetGone?.Invoke(this, new TargetChangedArgs { Target = target, TargetInfo = targetInfo });
             }
@@ -217,7 +215,7 @@ private void OnTargetInfoChanged(TargetCreatedResponse e)
             _discoveredTargetsByTargetId[e.TargetInfo.TargetId] = e.TargetInfo;
 
             if (_ignoredTargets.Contains(e.TargetInfo.TargetId) ||
-                !_attachedTargetsByTargetId.TryGetValue(e.TargetInfo.TargetId, out var target) ||
+                !_availableTargetsByTargetIdDictionary.TryGetValue(e.TargetInfo.TargetId, out var target) ||
                 !e.TargetInfo.Attached)
             {
                 return;
@@ -229,16 +227,10 @@ private void OnTargetInfoChanged(TargetCreatedResponse e)
         private async Task OnAttachedToTarget(object sender, TargetAttachedToTargetResponse e)
         {
             var parent = sender as ICDPConnection;
-            var parentSession = parent as CDPSession;
             var targetInfo = e.TargetInfo;
-            var session = _connection.GetSession(e.SessionId);
+            var session = _connection.GetSession(e.SessionId) ?? throw new PuppeteerException($"Session {e.SessionId} was not created.");
 
-            if (session == null)
-            {
-                throw new PuppeteerException($"Session {e.SessionId} was not created.");
-            }
-
-            Func<Task> silentDetach = async () =>
+            async Task SilentDetach()
             {
                 try
                 {
@@ -254,7 +246,7 @@ await parent.SendAsync(
                 {
                     _logger.LogError(ex, "silentDetach failed.");
                 }
-            };
+            }
 
             if (!_connection.IsAutoAttached(targetInfo.TargetId))
             {
@@ -266,14 +258,14 @@ await parent.SendAsync(
             {
                 await EnsureTargetsIdsForInit().ConfigureAwait(false);
                 FinishInitializationIfReady(targetInfo.TargetId);
-                await silentDetach().ConfigureAwait(false);
-                if (_attachedTargetsByTargetId.ContainsKey(targetInfo.TargetId))
+                await SilentDetach().ConfigureAwait(false);
+                if (_availableTargetsByTargetIdDictionary.ContainsKey(targetInfo.TargetId))
                 {
                     return;
                 }
 
                 var workerTarget = _targetFactoryFunc(targetInfo, null);
-                _attachedTargetsByTargetId.TryAdd(targetInfo.TargetId, workerTarget);
+                _attachedTargetsByTargetId.AddItem(targetInfo.TargetId, workerTarget);
                 TargetAvailable?.Invoke(this, new TargetChangedArgs { Target = workerTarget });
                 return;
             }
@@ -283,11 +275,11 @@ await parent.SendAsync(
                 _ignoredTargets.Add(targetInfo.TargetId);
                 await EnsureTargetsIdsForInit().ConfigureAwait(false);
                 FinishInitializationIfReady(targetInfo.TargetId);
-                await silentDetach().ConfigureAwait(false);
+                await SilentDetach().ConfigureAwait(false);
                 return;
             }
 
-            var existingTarget = _attachedTargetsByTargetId.TryGetValue(targetInfo.TargetId, out var target);
+            var existingTarget = _availableTargetsByTargetIdDictionary.TryGetValue(targetInfo.TargetId, out var target);
             if (!existingTarget)
             {
                 target = _targetFactoryFunc(targetInfo, session);
@@ -301,7 +293,7 @@ await parent.SendAsync(
             }
             else
             {
-                _attachedTargetsByTargetId.TryAdd(targetInfo.TargetId, target);
+                _attachedTargetsByTargetId.AddItem(targetInfo.TargetId, target);
                 _attachedTargetsBySessionId.TryAdd(session.Id, target);
             }
 
@@ -310,7 +302,7 @@ await parent.SendAsync(
                 foreach (var interceptor in interceptors)
                 {
                     Target parentTarget = null;
-                    if (parentSession != null && !_attachedTargetsBySessionId.TryGetValue(parentSession.Id, out parentTarget))
+                    if (parent is CDPSession parentSession && !_attachedTargetsBySessionId.TryGetValue(parentSession.Id, out parentTarget))
                     {
                         throw new PuppeteerException("Parent session not found in attached targets");
                     }
@@ -385,7 +377,7 @@ private void OnDetachedFromTarget(object sender, TargetDetachedFromTargetRespons
                 return;
             }
 
-            _attachedTargetsByTargetId.TryRemove(target.TargetId, out _);
+            _availableTargetsByTargetIdDictionary.TryRemove(target.TargetId, out _);
             TargetGone?.Invoke(this, new TargetChangedArgs { Target = target });
         }
     }
diff --git a/lib/PuppeteerSharp/FirefoxTargetManager.cs b/lib/PuppeteerSharp/FirefoxTargetManager.cs
@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
+using PuppeteerSharp.Helpers;
 using PuppeteerSharp.Helpers.Json;
 using PuppeteerSharp.Messaging;
 
@@ -16,7 +17,9 @@ internal class FirefoxTargetManager : ITargetManager
         private readonly Func<TargetInfo, bool> _targetFilterFunc;
         private readonly ILogger<FirefoxTargetManager> _logger;
         private readonly ConcurrentDictionary<ICDPConnection, List<TargetInterceptor>> _targetInterceptors = new();
-        private readonly ConcurrentDictionary<string, Target> _availableTargetsByTargetId = new();
+
+        private readonly ConcurrentDictionary<string, Target> _availableTargetsByTargetIdDictionary = new();
+        private readonly AsyncDictionaryHelper<string, Target> _availableTargetsByTargetId;
         private readonly ConcurrentDictionary<string, Target> _availableTargetsBySessionId = new();
         private readonly ConcurrentDictionary<string, TargetInfo> _discoveredTargetsByTargetId = new();
         private readonly TaskCompletionSource<bool> _initializeCompletionSource = new();
@@ -28,6 +31,7 @@ public FirefoxTargetManager(
             Func<TargetInfo, CDPSession, Target> targetFactoryFunc,
             Func<TargetInfo, bool> targetFilterFunc)
         {
+            _availableTargetsByTargetId = new AsyncDictionaryHelper<string, Target>(_availableTargetsByTargetIdDictionary, "Target {0} not found");
             _connection = connection;
             _targetFilterFunc = targetFilterFunc;
             _targetFactoryFunc = targetFactoryFunc;
@@ -72,7 +76,7 @@ public async Task InitializeAsync()
             await _initializeCompletionSource.Task.ConfigureAwait(false);
         }
 
-        public ConcurrentDictionary<string, Target> GetAvailableTargets() => _availableTargetsByTargetId;
+        public AsyncDictionaryHelper<string, Target> GetAvailableTargets() => _availableTargetsByTargetId;
 
         private void OnMessageReceived(object sender, MessageEventArgs e)
         {
@@ -116,7 +120,7 @@ private void OnTargetCreated(TargetCreatedResponse e)
             if (e.TargetInfo.Type == TargetType.Browser && e.TargetInfo.Attached)
             {
                 var browserTarget = _targetFactoryFunc(e.TargetInfo, null);
-                _availableTargetsByTargetId[e.TargetInfo.TargetId] = browserTarget;
+                _availableTargetsByTargetId.AddItem(e.TargetInfo.TargetId, browserTarget);
                 FinishInitializationIfReady(e.TargetInfo.TargetId);
             }
 
@@ -128,7 +132,7 @@ private void OnTargetCreated(TargetCreatedResponse e)
             }
 
             var target = _targetFactoryFunc(e.TargetInfo, null);
-            _availableTargetsByTargetId[e.TargetInfo.TargetId] = target;
+            _availableTargetsByTargetId.AddItem(e.TargetInfo.TargetId, target);
             TargetAvailable?.Invoke(
                 this,
                 new TargetChangedArgs
@@ -144,7 +148,7 @@ private void OnTargetDestroyed(TargetDestroyedResponse e)
             _discoveredTargetsByTargetId.TryRemove(e.TargetId, out var targetInfo);
             FinishInitializationIfReady(e.TargetId);
 
-            if (_availableTargetsByTargetId.TryRemove(e.TargetId, out var target))
+            if (_availableTargetsByTargetIdDictionary.TryGetValue(e.TargetId, out var target))
             {
                 TargetGone?.Invoke(this, new TargetChangedArgs { Target = target, TargetInfo = targetInfo });
             }
@@ -155,7 +159,7 @@ private void OnAttachedToTarget(object sender, TargetAttachedToTargetResponse e)
             var parent = sender as ICDPConnection;
             var targetInfo = e.TargetInfo;
             var session = _connection.GetSession(e.SessionId) ?? throw new PuppeteerException($"Session {e.SessionId} was not created.");
-            var existingTarget = _availableTargetsByTargetId.TryGetValue(targetInfo.TargetId, out var target);
+            var existingTarget = _availableTargetsByTargetIdDictionary.TryGetValue(targetInfo.TargetId, out var target);
             session.MessageReceived += OnMessageReceived;
 
             _availableTargetsBySessionId.TryAdd(session.Id, target);
diff --git a/lib/PuppeteerSharp/Helpers/AsyncDictionaryHelper.cs b/lib/PuppeteerSharp/Helpers/AsyncDictionaryHelper.cs
@@ -17,6 +17,8 @@ public AsyncDictionaryHelper(ConcurrentDictionary<TKey, TValue> dictionary, stri
             _timeoutMessage = timeoutMessage;
         }
 
+        internal ConcurrentDictionary<TKey, TValue> InnerDictionary => _dictionary;
+
         internal async Task<TValue> GetItemAsync(TKey key)
         {
             var tcs = new TaskCompletionSource<TValue>(TaskCreationOptions.RunContinuationsAsynchronously);
diff --git a/lib/PuppeteerSharp/ITargetManager.cs b/lib/PuppeteerSharp/ITargetManager.cs
@@ -3,6 +3,7 @@
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
+using PuppeteerSharp.Helpers;
 using PuppeteerSharp.Messaging;
 using PuppeteerSharp.Transport;
 
@@ -39,7 +40,7 @@ internal interface ITargetManager
         /// All the available targets.
         /// </summary>
         /// <returns>A dictionary with the available targets.</returns>
-        ConcurrentDictionary<string, Target> GetAvailableTargets();
+        AsyncDictionaryHelper<string, Target> GetAvailableTargets();
 
         /// <summary>
         /// Async tasks to be performed after calling the target manager constructor.
diff --git a/lib/PuppeteerSharp/PuppeteerSharp.csproj b/lib/PuppeteerSharp/PuppeteerSharp.csproj
@@ -12,10 +12,10 @@
     <Description>Headless Browser .NET API</Description>
     <PackageId>PuppeteerSharp</PackageId>
     <PackageReleaseNotes></PackageReleaseNotes>
-    <PackageVersion>10.1.3</PackageVersion>
-    <ReleaseVersion>10.1.3</ReleaseVersion>
-    <AssemblyVersion>10.1.3.0</AssemblyVersion>
-    <FileVersion>10.1.3.0</FileVersion>
+    <PackageVersion>10.1.4</PackageVersion>
+    <ReleaseVersion>10.1.4</ReleaseVersion>
+    <AssemblyVersion>10.1.4.0</AssemblyVersion>
+    <FileVersion>10.1.4.0</FileVersion>
     <SynchReleaseVersion>false</SynchReleaseVersion>
     <StyleCopTreatErrorsAsWarnings>false</StyleCopTreatErrorsAsWarnings>
     <DebugType>embedded</DebugType>
diff --git a/lib/PuppeteerSharp/Target.cs b/lib/PuppeteerSharp/Target.cs
@@ -88,7 +88,7 @@ internal Target(
 
         /// <inheritdoc/>
         public ITarget Opener => TargetInfo.OpenerId != null ?
-            ((Browser)Browser).TargetManager.GetAvailableTargets().GetValueOrDefault(TargetInfo.OpenerId) : null;
+            ((Browser)Browser).TargetManager.GetAvailableTargets().InnerDictionary.GetValueOrDefault(TargetInfo.OpenerId) : null;
 
         /// <inheritdoc/>
         public IBrowser Browser => BrowserContext.Browser;

Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ public async Task BackgroundPageTargetTypeShouldBeAvailable()`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`[PuppeteerTest("headful.spec.ts", "HEADFUL", "target.page() should return a background_page")]`
`43`		`- [Skip(SkipAttribute.Targets.Firefox)]`
	`43`	`+ [Ignore("Marked as Fail/Pass upstream")]`
`44`	`44`	`public async Task TargetPageShouldReturnABackgroundPage()`
`45`	`45`	`{`
`46`	`46`	`await using (var browserWithExtension = await Puppeteer.LaunchAsync(`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,8 @@ internal class ChromeTargetManager : ITargetManager`
`19`	`19`	`private readonly Func<TargetInfo, CDPSession, Target> _targetFactoryFunc;`
`20`	`20`	`private readonly Func<TargetInfo, bool> _targetFilterFunc;`
`21`	`21`	`private readonly ILogger<ChromeTargetManager> _logger;`
`22`		`- private readonly ConcurrentDictionary<string, Target> _attachedTargetsByTargetId = new();`
	`22`	`+ private readonly ConcurrentDictionary<string, Target> _availableTargetsByTargetIdDictionary = new();`
	`23`	`+ private readonly AsyncDictionaryHelper<string, Target> _attachedTargetsByTargetId;`
`23`	`24`	`private readonly ConcurrentDictionary<string, Target> _attachedTargetsBySessionId = new();`
`24`	`25`	`private readonly ConcurrentDictionary<string, TargetInfo> _discoveredTargetsByTargetId = new();`
`25`	`26`	`private readonly ConcurrentDictionary<ICDPConnection, List<TargetInterceptor>> _targetInterceptors = new();`
`@@ -36,6 +37,7 @@ public ChromeTargetManager(`
`36`	`37`	`Func<TargetInfo, bool> targetFilterFunc,`
`37`	`38`	`int targetDiscoveryTimeout = 0)`
`38`	`39`	`{`
	`40`	`+ _attachedTargetsByTargetId = new AsyncDictionaryHelper<string, Target>(_availableTargetsByTargetIdDictionary, "Target {0} not found");`
`39`	`41`	`_connection = connection;`
`40`	`42`	`_targetFilterFunc = targetFilterFunc;`
`41`	`43`	`_targetFactoryFunc = targetFactoryFunc;`
`@@ -86,7 +88,7 @@ public ChromeTargetManager(`
`86`	`88`
`87`	`89`	`public event EventHandler<TargetChangedArgs> TargetDiscovered;`
`88`	`90`
`89`		`- public ConcurrentDictionary<string, Target> GetAvailableTargets() => _attachedTargetsByTargetId;`
	`91`	`+ public AsyncDictionaryHelper<string, Target> GetAvailableTargets() => _attachedTargetsByTargetId;`
`90`	`92`
`91`	`93`	`public async Task InitializeAsync()`
`92`	`94`	`{`
`@@ -112,11 +114,7 @@ public void AddTargetInterceptor(CDPSession session, TargetInterceptor intercept`
`112`	`114`	`public void RemoveTargetInterceptor(CDPSession session, TargetInterceptor interceptor)`
`113`	`115`	`{`
`114`	`116`	`_targetInterceptors.TryGetValue(session, out var interceptors);`
`115`		`-`
`116`		`- if (interceptors != null)`
`117`		`- {`
`118`		`- interceptors.Remove(interceptor);`
`119`		`- }`
	`117`	`+ interceptors?.Remove(interceptor);`
`120`	`118`	`}`
`121`	`119`
`122`	`120`	`private void StoreExistingTargetsForInit()`
`@@ -190,13 +188,13 @@ private void OnTargetCreated(TargetCreatedResponse e)`
`190`	`188`
`191`	`189`	`if (e.TargetInfo.Type == TargetType.Browser && e.TargetInfo.Attached)`
`192`	`190`	`{`
`193`		`- if (_attachedTargetsByTargetId.ContainsKey(e.TargetInfo.TargetId))`
	`191`	`+ if (_availableTargetsByTargetIdDictionary.ContainsKey(e.TargetInfo.TargetId))`
`194`	`192`	`{`
`195`	`193`	`return;`
`196`	`194`	`}`
`197`	`195`
`198`	`196`	`var target = _targetFactoryFunc(e.TargetInfo, null);`
`199`		`- _attachedTargetsByTargetId[e.TargetInfo.TargetId] = target;`
	`197`	`+ _attachedTargetsByTargetId.AddItem(e.TargetInfo.TargetId, target);`
`200`	`198`	`}`
`201`	`199`	`}`
`202`	`200`
`@@ -206,7 +204,7 @@ private async void OnTargetDestroyed(TargetDestroyedResponse e)`
`206`	`204`	`await EnsureTargetsIdsForInit().ConfigureAwait(false);`
`207`	`205`	`FinishInitializationIfReady(e.TargetId);`
`208`	`206`
`209`		`- if (targetInfo?.Type == TargetType.ServiceWorker && _attachedTargetsByTargetId.TryRemove(e.TargetId, out var target))`
	`207`	`+ if (targetInfo?.Type == TargetType.ServiceWorker && _availableTargetsByTargetIdDictionary.TryRemove(e.TargetId, out var target))`
`210`	`208`	`{`
`211`	`209`	`TargetGone?.Invoke(this, new TargetChangedArgs { Target = target, TargetInfo = targetInfo });`
`212`	`210`	`}`
`@@ -217,7 +215,7 @@ private void OnTargetInfoChanged(TargetCreatedResponse e)`
`217`	`215`	`_discoveredTargetsByTargetId[e.TargetInfo.TargetId] = e.TargetInfo;`
`218`	`216`
`219`	`217`	`if (_ignoredTargets.Contains(e.TargetInfo.TargetId) \|\|`
`220`		`- !_attachedTargetsByTargetId.TryGetValue(e.TargetInfo.TargetId, out var target) \|\|`
	`218`	`+ !_availableTargetsByTargetIdDictionary.TryGetValue(e.TargetInfo.TargetId, out var target) \|\|`
`221`	`219`	`!e.TargetInfo.Attached)`
`222`	`220`	`{`
`223`	`221`	`return;`
`@@ -229,16 +227,10 @@ private void OnTargetInfoChanged(TargetCreatedResponse e)`
`229`	`227`	`private async Task OnAttachedToTarget(object sender, TargetAttachedToTargetResponse e)`
`230`	`228`	`{`
`231`	`229`	`var parent = sender as ICDPConnection;`
`232`		`- var parentSession = parent as CDPSession;`
`233`	`230`	`var targetInfo = e.TargetInfo;`
`234`		`- var session = _connection.GetSession(e.SessionId);`
	`231`	`+ var session = _connection.GetSession(e.SessionId) ?? throw new PuppeteerException($"Session {e.SessionId} was not created.");`
`235`	`232`
`236`		`- if (session == null)`
`237`		`- {`
`238`		`- throw new PuppeteerException($"Session {e.SessionId} was not created.");`
`239`		`- }`
`240`		`-`
`241`		`- Func<Task> silentDetach = async () =>`
	`233`	`+ async Task SilentDetach()`
`242`	`234`	`{`
`243`	`235`	`try`
`244`	`236`	`{`
`@@ -254,7 +246,7 @@ await parent.SendAsync(`
`254`	`246`	`{`
`255`	`247`	`_logger.LogError(ex, "silentDetach failed.");`
`256`	`248`	`}`
`257`		`- };`
	`249`	`+ }`
`258`	`250`
`259`	`251`	`if (!_connection.IsAutoAttached(targetInfo.TargetId))`
`260`	`252`	`{`
`@@ -266,14 +258,14 @@ await parent.SendAsync(`
`266`	`258`	`{`
`267`	`259`	`await EnsureTargetsIdsForInit().ConfigureAwait(false);`
`268`	`260`	`FinishInitializationIfReady(targetInfo.TargetId);`
`269`		`- await silentDetach().ConfigureAwait(false);`
`270`		`- if (_attachedTargetsByTargetId.ContainsKey(targetInfo.TargetId))`
	`261`	`+ await SilentDetach().ConfigureAwait(false);`
	`262`	`+ if (_availableTargetsByTargetIdDictionary.ContainsKey(targetInfo.TargetId))`
`271`	`263`	`{`
`272`	`264`	`return;`
`273`	`265`	`}`
`274`	`266`
`275`	`267`	`var workerTarget = _targetFactoryFunc(targetInfo, null);`
`276`		`- _attachedTargetsByTargetId.TryAdd(targetInfo.TargetId, workerTarget);`
	`268`	`+ _attachedTargetsByTargetId.AddItem(targetInfo.TargetId, workerTarget);`
`277`	`269`	`TargetAvailable?.Invoke(this, new TargetChangedArgs { Target = workerTarget });`
`278`	`270`	`return;`
`279`	`271`	`}`
`@@ -283,11 +275,11 @@ await parent.SendAsync(`
`283`	`275`	`_ignoredTargets.Add(targetInfo.TargetId);`
`284`	`276`	`await EnsureTargetsIdsForInit().ConfigureAwait(false);`
`285`	`277`	`FinishInitializationIfReady(targetInfo.TargetId);`
`286`		`- await silentDetach().ConfigureAwait(false);`
	`278`	`+ await SilentDetach().ConfigureAwait(false);`
`287`	`279`	`return;`
`288`	`280`	`}`
`289`	`281`
`290`		`- var existingTarget = _attachedTargetsByTargetId.TryGetValue(targetInfo.TargetId, out var target);`
	`282`	`+ var existingTarget = _availableTargetsByTargetIdDictionary.TryGetValue(targetInfo.TargetId, out var target);`
`291`	`283`	`if (!existingTarget)`
`292`	`284`	`{`
`293`	`285`	`target = _targetFactoryFunc(targetInfo, session);`
`@@ -301,7 +293,7 @@ await parent.SendAsync(`
`301`	`293`	`}`
`302`	`294`	`else`
`303`	`295`	`{`
`304`		`- _attachedTargetsByTargetId.TryAdd(targetInfo.TargetId, target);`
	`296`	`+ _attachedTargetsByTargetId.AddItem(targetInfo.TargetId, target);`
`305`	`297`	`_attachedTargetsBySessionId.TryAdd(session.Id, target);`
`306`	`298`	`}`
`307`	`299`
`@@ -310,7 +302,7 @@ await parent.SendAsync(`
`310`	`302`	`foreach (var interceptor in interceptors)`
`311`	`303`	`{`
`312`	`304`	`Target parentTarget = null;`
`313`		`- if (parentSession != null && !_attachedTargetsBySessionId.TryGetValue(parentSession.Id, out parentTarget))`
	`305`	`+ if (parent is CDPSession parentSession && !_attachedTargetsBySessionId.TryGetValue(parentSession.Id, out parentTarget))`
`314`	`306`	`{`
`315`	`307`	`throw new PuppeteerException("Parent session not found in attached targets");`
`316`	`308`	`}`
`@@ -385,7 +377,7 @@ private void OnDetachedFromTarget(object sender, TargetDetachedFromTargetRespons`
`385`	`377`	`return;`
`386`	`378`	`}`
`387`	`379`
`388`		`- _attachedTargetsByTargetId.TryRemove(target.TargetId, out _);`
	`380`	`+ _availableTargetsByTargetIdDictionary.TryRemove(target.TargetId, out _);`
`389`	`381`	`TargetGone?.Invoke(this, new TargetChangedArgs { Target = target });`
`390`	`382`	`}`
`391`	`383`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,8 @@ public AsyncDictionaryHelper(ConcurrentDictionary<TKey, TValue> dictionary, stri`
`17`	`17`	`_timeoutMessage = timeoutMessage;`
`18`	`18`	`}`
`19`	`19`
	`20`	`+ internal ConcurrentDictionary<TKey, TValue> InnerDictionary => _dictionary;`
	`21`	`+`
`20`	`22`	`internal async Task<TValue> GetItemAsync(TKey key)`
`21`	`23`	`{`
`22`	`24`	`var tcs = new TaskCompletionSource<TValue>(TaskCreationOptions.RunContinuationsAsynchronously);`