How to use EnterFromAsync method of PuppeteerSharp.States.ChromiumStartingState class

1using System;
2using System.Diagnostics;
3using System.Text;
4using System.Text.RegularExpressions;
5using System.Threading;
6using System.Threading.Tasks;
7
8namespace PuppeteerSharp.States
9{
10    internal class ChromiumStartingState : State
11    {
12        public ChromiumStartingState(StateManager stateManager) : base(stateManager)
13        {
14        }
15
16        public override Task EnterFromAsync(LauncherBase p, State fromState, TimeSpan timeout)
17        {
18            if (!StateManager.TryEnter(p, fromState, this))
19            {
20                // Delegate StartAsync to current state, because it has already changed since
21                // transition to this state was initiated.
22                return StateManager.CurrentState.StartAsync(p);
23            }
24
25            return StartCoreAsync(p);
26        }
27
28        public override Task StartAsync(LauncherBase p) => p.StartCompletionSource.Task;
29
30        public override Task ExitAsync(LauncherBase p, TimeSpan timeout) => StateManager.Exiting.EnterFromAsync(p, this, timeout);
31
32        public override Task KillAsync(LauncherBase p) => StateManager.Killing.EnterFromAsync(p, this);
33
34        public override void Dispose(LauncherBase p)
35        {
36            p.StartCompletionSource.TrySetException(new ObjectDisposedException(p.ToString()));
37            base.Dispose(p);
38        }
39
40        protected virtual async Task StartCoreAsync(LauncherBase p)
41        {
42            var output = new StringBuilder();
43
44            void OnProcessDataReceivedWhileStarting(object sender, DataReceivedEventArgs e)
45            {
46                if (e.Data != null)
47                {
48                    output.AppendLine(e.Data);
49                    var match = Regex.Match(e.Data, "^DevTools listening on (ws:\\/\\/.*)");
50                    if (match.Success)
51                    {
52                        p.StartCompletionSource.TrySetResult(match.Groups[1].Value);
53                    }
54                }
55            }
56
57            void OnProcessExitedWhileStarting(object sender, EventArgs e)
58                => p.StartCompletionSource.TrySetException(new ProcessException($"Failed to launch browser! {output}"));
59
60            void OnProcessExited(object sender, EventArgs e) => StateManager.Exited.EnterFrom(p, StateManager.CurrentState);
61
62            p.Process.ErrorDataReceived += OnProcessDataReceivedWhileStarting;
63            p.Process.Exited += OnProcessExitedWhileStarting;
64            p.Process.Exited += OnProcessExited;
65            CancellationTokenSource cts = null;
66            try
67            {
68                p.Process.Start();
69                await StateManager.Started.EnterFromAsync(p, this).ConfigureAwait(false);
70
71                p.Process.BeginErrorReadLine();
72
73                var timeout = p.Options.Timeout;
74                if (timeout > 0)
75                {
76                    cts = new CancellationTokenSource(timeout);
77                    cts.Token.Register(() => p.StartCompletionSource.TrySetException(
78                        new ProcessException($"Timed out after {timeout} ms while trying to connect to Base!")));
79                }
80
81                try
82                {
83                    await p.StartCompletionSource.Task.ConfigureAwait(false);
84                    await StateManager.Started.EnterFromAsync(p, this).ConfigureAwait(false);
85                }
86                catch
87                {
88                    await StateManager.Killing.EnterFromAsync(p, this).ConfigureAwait(false);
89                    throw;
90                }
91            }
92            finally
93            {
94                cts?.Dispose();
95                p.Process.Exited -= OnProcessExitedWhileStarting;
96                p.Process.ErrorDataReceived -= OnProcessDataReceivedWhileStarting;
97            }
98        }
99    }
100}
101

Source: ChromiumStartingState.cs

using System;
using System.Diagnostics;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;

namespace PuppeteerSharp.States
{
    internal class ChromiumStartingState : State
    {
        public ChromiumStartingState(StateManager stateManager) : base(stateManager)
        {
        }

        public override Task EnterFromAsync(LauncherBase p, State fromState, TimeSpan timeout)
        {
            if (!StateManager.TryEnter(p, fromState, this))
            {
                // Delegate StartAsync to current state, because it has already changed since
                // transition to this state was initiated.
                return StateManager.CurrentState.StartAsync(p);
            }

            return StartCoreAsync(p);
        }

        public override Task StartAsync(LauncherBase p) => p.StartCompletionSource.Task;

        public override Task ExitAsync(LauncherBase p, TimeSpan timeout) => StateManager.Exiting.EnterFromAsync(p, this, timeout);

        public override Task KillAsync(LauncherBase p) => StateManager.Killing.EnterFromAsync(p, this);

        public override void Dispose(LauncherBase p)
        {
            p.StartCompletionSource.TrySetException(new ObjectDisposedException(p.ToString()));
            base.Dispose(p);
        }

        protected virtual async Task StartCoreAsync(LauncherBase p)
        {
            var output = new StringBuilder();

            void OnProcessDataReceivedWhileStarting(object sender, DataReceivedEventArgs e)
            {
                if (e.Data != null)
                {
                    output.AppendLine(e.Data);
                    var match = Regex.Match(e.Data, "^DevTools listening on (ws:\\/\\/.*)");
                    if (match.Success)
                    {
                        p.StartCompletionSource.TrySetResult(match.Groups[1].Value);
                    }
                }
            }

            void OnProcessExitedWhileStarting(object sender, EventArgs e)
                => p.StartCompletionSource.TrySetException(new ProcessException($"Failed to launch browser! {output}"));

            void OnProcessExited(object sender, EventArgs e) => StateManager.Exited.EnterFrom(p, StateManager.CurrentState);

            p.Process.ErrorDataReceived += OnProcessDataReceivedWhileStarting;
            p.Process.Exited += OnProcessExitedWhileStarting;
            p.Process.Exited += OnProcessExited;
            CancellationTokenSource cts = null;
            try
            {
                p.Process.Start();
                await StateManager.Started.EnterFromAsync(p, this).ConfigureAwait(false);

                p.Process.BeginErrorReadLine();

                var timeout = p.Options.Timeout;
                if (timeout > 0)
                {
                    cts = new CancellationTokenSource(timeout);
                    cts.Token.Register(() => p.StartCompletionSource.TrySetException(
                        new ProcessException($"Timed out after {timeout} ms while trying to connect to Base!")));
                }

                try
                {
                    await p.StartCompletionSource.Task.ConfigureAwait(false);
                    await StateManager.Started.EnterFromAsync(p, this).ConfigureAwait(false);
                }
                catch
                {
                    await StateManager.Killing.EnterFromAsync(p, this).ConfigureAwait(false);
                    throw;
                }
            }
            finally
            {
                cts?.Dispose();
                p.Process.Exited -= OnProcessExitedWhileStarting;
                p.Process.ErrorDataReceived -= OnProcessDataReceivedWhileStarting;
            }
        }
    }
}