Introduce protocol in launch options

.github/workflows/dotnet.yml

@@ -20,7 +20,7 @@ env:
 
 jobs:
   build:
-    name: build-${{ matrix.browser }}-${{ matrix.mode }}-${{ matrix.os }}
+    name: build-${{ matrix.browser }}-${{ matrix.mode }}-${{ matrix.os }}-${{ matrix.protocol }}
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
@@ -29,33 +29,63 @@ jobs:
           - os: ubuntu-latest
             browser: CHROME
             mode: headless
+            protocol: cdp
           - os: ubuntu-latest
             browser: CHROME
             mode: headful
+            protocol: cdp
           - os: ubuntu-latest
             browser: CHROME
             mode: headless-shell
+            protocol: cdp
           - os: ubuntu-latest
             browser: FIREFOX
             mode: headless
+            protocol: cdp
           - os: ubuntu-latest
             browser: FIREFOX
             mode: headful
+            protocol: cdp
           - os: windows-latest
             browser: CHROME
             mode: headless
+            protocol: cdp
           - os: windows-latest
             browser: CHROME
             mode: headful
+            protocol: cdp
           - os: windows-latest
             browser: CHROME
             mode: headless-shell
+            protocol: cdp
           - os: windows-latest
             browser: FIREFOX
             mode: headless
+            protocol: cdp
           - os: windows-latest
             browser: FIREFOX
             mode: headful
+            protocol: cdp
+          - os: ubuntu-latest
+            browser: CHROME
+            mode: headless
+            protocol: webdriverbidi
+          - os: ubuntu-latest
+            browser: CHROME
+            mode: headful
+            protocol: webdriverbidi
+          - os: ubuntu-latest
+            browser: CHROME
+            mode: headless-shell
+            protocol: webdriverbidi
+          - os: ubuntu-latest
+            browser: FIREFOX
+            mode: headless
+            protocol: webdriverbidi
+          - os: ubuntu-latest
+            browser: FIREFOX
+            mode: headful
+            protocol: webdriverbidi
     steps:
     - uses: actions/checkout@v3
     - name: Setup .NET Core
@@ -83,7 +113,7 @@ jobs:
         New-SelfSignedCertificate -Subject "localhost" -FriendlyName "Puppeteer" -CertStoreLocation "cert:\CurrentUser\My"
         Get-ChildItem -Path cert:\CurrentUSer\my | where { $_.friendlyname -eq "Puppeteer" } | Export-Certificate -FilePath $env:GITHUB_WORKSPACE\lib\PuppeteerSharp.TestServer\testCert.cer
     - name: Check formatting
-      if: ${{ matrix.os == 'ubuntu-latest' && matrix.browser == 'CHROME' && matrix.mode == 'headless' }}
+      if: ${{ matrix.os == 'ubuntu-latest' && matrix.browser == 'CHROME' && matrix.mode == 'headless' && matrix.protocol == 'cdp' }}
       run: dotnet format ./lib/PuppeteerSharp.sln --verify-no-changes
     - name: Build
       working-directory: lib
@@ -93,6 +123,7 @@ jobs:
       env:
         PRODUCT: ${{ matrix.browser }}
         HEADLESS_MODE: ${{ matrix.mode }}
+        PROTOCOL: ${{ matrix.protocol }}
       run: |
           Xvfb :1 -screen 5 1024x768x8 &
           export DISPLAY=:1.5
@@ -103,6 +134,7 @@ jobs:
       env:
         PRODUCT: ${{ matrix.browser }}
         HEADLESS_MODE: ${{ matrix.mode }}
+        PROTOCOL: ${{ matrix.protocol }}
       run: |
         cd .\lib\PuppeteerSharp.Tests
         dotnet test -s test.runsettings --blame-hang-timeout 300000

lib/PuppeteerSharp.Nunit/PuppeteerTestAttribute.cs

@@ -21,8 +21,7 @@ public class PuppeteerTestAttribute : NUnitAttribute, IApplyToTest
         private static TestExpectation[] _localExpectations;
         private static TestExpectation[] _upstreamExpectations;
         public static readonly bool IsChrome = Environment.GetEnvironmentVariable("PRODUCT") != "FIREFOX";
-        // TODO: Change implementation when we implement Webdriver Bidi
-        public static readonly bool IsCdp = true;
+        public static readonly bool IsCdp = Environment.GetEnvironmentVariable("PROTOCOL") != "webdriverbidi";
         public static readonly HeadlessMode Headless =
             string.IsNullOrEmpty(Environment.GetEnvironmentVariable("HEADLESS_MODE")) ?
             (System.Diagnostics.Debugger.IsAttached ? HeadlessMode.False : HeadlessMode.True) :

lib/PuppeteerSharp.Tests/BrowserContextTests/BrowserContextTests.cs

@@ -142,7 +142,8 @@ public async Task ShouldWorkAcrossSessions()
 
             var remoteBrowser = await Puppeteer.ConnectAsync(new ConnectOptions
             {
-                BrowserWSEndpoint = Browser.WebSocketEndpoint
+                BrowserWSEndpoint = Browser.WebSocketEndpoint,
+                Protocol = ((Browser)Browser).Protocol,
             });
             var contexts = remoteBrowser.BrowserContexts();
             Assert.AreEqual(2, contexts.Length);

lib/PuppeteerSharp.Tests/BrowserTests/IsConnectedTests.cs

@@ -6,16 +6,13 @@ namespace PuppeteerSharp.Tests.BrowserTests
 {
     public class IsConnectedTests : PuppeteerBrowserBaseTest
     {
-        public IsConnectedTests() : base()
-        {
-        }
-
         [Test, Retry(2), PuppeteerTest("browser.spec", "Browser.isConnected", "should set the browser connected state")]
         public async Task ShouldSetTheBrowserConnectedState()
         {
             var newBrowser = await Puppeteer.ConnectAsync(new ConnectOptions
             {
-                BrowserWSEndpoint = Browser.WebSocketEndpoint
+                BrowserWSEndpoint = Browser.WebSocketEndpoint,
+                Protocol = ((Browser)Browser).Protocol,
             });
             Assert.True(newBrowser.IsConnected);
             newBrowser.Disconnect();

lib/PuppeteerSharp.Tests/BrowserTests/ProcessTests.cs

@@ -6,8 +6,6 @@ namespace PuppeteerSharp.Tests.BrowserTests
 {
     public class ProcessTests : PuppeteerBrowserBaseTest
     {
-        public ProcessTests() : base() { }
-
         [Test, Retry(2), PuppeteerTest("browser.spec", "Browser.process", "should return child_process instance")]
         public void ShouldReturnProcessInstance()
         {
@@ -20,7 +18,12 @@ public async Task ShouldNotReturnChildProcessForRemoteBrowser()
         {
             var browserWSEndpoint = Browser.WebSocketEndpoint;
             var remoteBrowser = await Puppeteer.ConnectAsync(
-                new ConnectOptions { BrowserWSEndpoint = browserWSEndpoint }, TestConstants.LoggerFactory);
+                new ConnectOptions
+                {
+                    BrowserWSEndpoint = browserWSEndpoint,
+                    Protocol = ((Browser)Browser).Protocol,
+                },
+                TestConstants.LoggerFactory);
             Assert.Null(remoteBrowser.Process);
             remoteBrowser.Disconnect();
         }

lib/PuppeteerSharp.Tests/LauncherTests/BrowserCloseTests.cs

@@ -6,30 +6,28 @@ namespace PuppeteerSharp.Tests.BrowserTests.Events
 {
     public class BrowserCloseTests : PuppeteerBrowserBaseTest
     {
-        public BrowserCloseTests() : base()
-        {
-        }
-
         [Test, Retry(2), PuppeteerTest("launcher.spec", "Launcher specs Browser.close", "should terminate network waiters")]
         public async Task ShouldTerminateNetworkWaiters()
         {
-            await using (var browser = await Puppeteer.LaunchAsync(TestConstants.DefaultBrowserOptions()))
-            await using (var remote = await Puppeteer.ConnectAsync(new ConnectOptions { BrowserWSEndpoint = browser.WebSocketEndpoint }))
+            await using var browser = await Puppeteer.LaunchAsync(TestConstants.DefaultBrowserOptions());
+            await using var remote = await Puppeteer.ConnectAsync(new ConnectOptions
             {
-                var newPage = await remote.NewPageAsync();
-                var requestTask = newPage.WaitForRequestAsync(TestConstants.EmptyPage);
-                var responseTask = newPage.WaitForResponseAsync(TestConstants.EmptyPage);
+                BrowserWSEndpoint = browser.WebSocketEndpoint,
+                Protocol = ((Browser)browser).Protocol,
+            });
+            var newPage = await remote.NewPageAsync();
+            var requestTask = newPage.WaitForRequestAsync(TestConstants.EmptyPage);
+            var responseTask = newPage.WaitForResponseAsync(TestConstants.EmptyPage);
 
-                await browser.CloseAsync();
+            await browser.CloseAsync();
 
-                var exception = Assert.ThrowsAsync<TargetClosedException>(() => requestTask);
-                StringAssert.Contains("Target closed", exception.Message);
-                StringAssert.DoesNotContain("Timeout", exception.Message);
+            var exception = Assert.ThrowsAsync<TargetClosedException>(() => requestTask);
+            StringAssert.Contains("Target closed", exception.Message);
+            StringAssert.DoesNotContain("Timeout", exception.Message);
 
-                exception = Assert.ThrowsAsync<TargetClosedException>(() => responseTask);
-                StringAssert.Contains("Target closed", exception.Message);
-                StringAssert.DoesNotContain("Timeout", exception.Message);
-            }
+            exception = Assert.ThrowsAsync<TargetClosedException>(() => responseTask);
+            StringAssert.Contains("Target closed", exception.Message);
+            StringAssert.DoesNotContain("Timeout", exception.Message);
         }
     }
 }

lib/PuppeteerSharp.Tests/LauncherTests/BrowserDisconnectTests.cs

@@ -15,7 +15,8 @@ public async Task ShouldRejectNavigationWhenBrowserCloses()
             await using var browser = await Puppeteer.LaunchAsync(TestConstants.DefaultBrowserOptions());
             var remote = await Puppeteer.ConnectAsync(new ConnectOptions
             {
-                BrowserWSEndpoint = browser.WebSocketEndpoint
+                BrowserWSEndpoint = browser.WebSocketEndpoint,
+                Protocol = ((Browser)Browser).Protocol,
             });
             var page = await remote.NewPageAsync();
             var navigationTask = page.GoToAsync(TestConstants.ServerUrl + "/one-style.html", new NavigationOptions
@@ -41,7 +42,8 @@ public async Task ShouldRejectWaitForSelectorWhenBrowserCloses()
             await using var browser = await Puppeteer.LaunchAsync(TestConstants.DefaultBrowserOptions());
             var remote = await Puppeteer.ConnectAsync(new ConnectOptions
             {
-                BrowserWSEndpoint = browser.WebSocketEndpoint
+                BrowserWSEndpoint = browser.WebSocketEndpoint,
+                Protocol = ((Browser)browser).Protocol,
             });
             var page = await remote.NewPageAsync();
             var watchdog = page.WaitForSelectorAsync("div", new WaitForSelectorOptions { Timeout = 60000 });

lib/PuppeteerSharp.Tests/LauncherTests/BrowserEventsDisconnectedTests.cs

@@ -14,7 +14,11 @@ public BrowserEventsDisconnectedTests() : base()
         public async Task ShouldEmittedWhenBrowserGetsClosedDisconnectedOrUnderlyingWebsocketGetsClosed()
         {
             var originalBrowser = await Puppeteer.LaunchAsync(TestConstants.DefaultBrowserOptions(), TestConstants.LoggerFactory);
-            var connectOptions = new ConnectOptions { BrowserWSEndpoint = originalBrowser.WebSocketEndpoint };
+            var connectOptions = new ConnectOptions
+            {
+                BrowserWSEndpoint = originalBrowser.WebSocketEndpoint,
+                Protocol = ((Browser)Browser).Protocol,
+            };
             var remoteBrowser1 = await Puppeteer.ConnectAsync(connectOptions, TestConstants.LoggerFactory);
             var remoteBrowser2 = await Puppeteer.ConnectAsync(connectOptions, TestConstants.LoggerFactory);
 

lib/PuppeteerSharp.Tests/LauncherTests/PuppeteerConnectTests.cs

@@ -1,4 +1,3 @@
-using System;
 using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Connections.Features;
@@ -11,16 +10,13 @@ namespace PuppeteerSharp.Tests.LauncherTests
 {
     public class PuppeteerConnectTests : PuppeteerBrowserBaseTest
     {
-        public PuppeteerConnectTests() : base()
-        {
-        }
-
         [Test, Retry(2), PuppeteerTest("launcher.spec", "Launcher specs Puppeteer Puppeteer.connect", "should be able to connect multiple times to the same browser")]
         public async Task ShouldBeAbleToConnectMultipleTimesToSameBrowser()
         {
             var options = new ConnectOptions()
             {
-                BrowserWSEndpoint = Browser.WebSocketEndpoint
+                BrowserWSEndpoint = Browser.WebSocketEndpoint,
+                Protocol = ((Browser)Browser).Protocol,
             };
             var browser = await Puppeteer.ConnectAsync(options, TestConstants.LoggerFactory);
             await using (var page = await browser.NewPageAsync())
@@ -55,30 +51,29 @@ public async Task ShouldBeAbleToCloseRemoteBrowser()
         [Test, Retry(2), PuppeteerTest("launcher.spec", "Launcher specs Puppeteer Puppeteer.connect", "should support ignoreHTTPSErrors option")]
         public async Task ShouldSupportIgnoreHTTPSErrorsOption()
         {
-            await using (var originalBrowser = await Puppeteer.LaunchAsync(TestConstants.DefaultBrowserOptions()))
-            await using (var browser = await Puppeteer.ConnectAsync(new ConnectOptions
+            await using var originalBrowser = await Puppeteer.LaunchAsync(TestConstants.DefaultBrowserOptions());
+            await using var browser = await Puppeteer.ConnectAsync(new ConnectOptions
             {
                 BrowserWSEndpoint = originalBrowser.WebSocketEndpoint,
-                IgnoreHTTPSErrors = true
-            }))
-            await using (var page = await browser.NewPageAsync())
-            {
-                var requestTask = HttpsServer.WaitForRequest(
-                    "/empty.html",
-                    request => request?.HttpContext?.Features?.Get<ITlsHandshakeFeature>()?.Protocol);
-                var responseTask = page.GoToAsync(TestConstants.HttpsPrefix + "/empty.html");
-
-                await Task.WhenAll(
-                    requestTask,
-                    responseTask).WithTimeout(Puppeteer.DefaultTimeout);
-
-                var response = responseTask.Result;
-                Assert.True(response.Ok);
-                Assert.NotNull(response.SecurityDetails);
-                Assert.AreEqual(
-                    TestUtils.CurateProtocol(requestTask.Result.ToString()),
-                    TestUtils.CurateProtocol(response.SecurityDetails.Protocol));
-            }
+                IgnoreHTTPSErrors = true,
+                Protocol = ((Browser)Browser).Protocol,
+            });
+            await using var page = await browser.NewPageAsync();
+            var requestTask = HttpsServer.WaitForRequest(
+                "/empty.html",
+                request => request?.HttpContext.Features.Get<ITlsHandshakeFeature>()?.Protocol);
+            var responseTask = page.GoToAsync(TestConstants.HttpsPrefix + "/empty.html");
+
+            await Task.WhenAll(
+                requestTask,
+                responseTask).WithTimeout(Puppeteer.DefaultTimeout);
+
+            var response = responseTask.Result;
+            Assert.True(response.Ok);
+            Assert.NotNull(response.SecurityDetails);
+            Assert.AreEqual(
+                TestUtils.CurateProtocol(requestTask.Result.ToString()),
+                TestUtils.CurateProtocol(response.SecurityDetails.Protocol));
         }
 
         [Test, Retry(2), PuppeteerTest("launcher.spec", "Launcher specs Puppeteer Puppeteer.connect", "should support targetFilter option")]
@@ -94,7 +89,8 @@ public async Task ShouldSupportTargetFilter()
             var remoteBrowser = await Puppeteer.ConnectAsync(new ConnectOptions
             {
                 BrowserWSEndpoint = browser.WebSocketEndpoint,
-                TargetFilter = (Target target) => !target.Url.Contains("should-be-ignored"),
+                TargetFilter = target => !target.Url.Contains("should-be-ignored"),
+                Protocol = ((Browser)browser).Protocol,
             }, TestConstants.LoggerFactory);
 
             var pages = await remoteBrowser.PagesAsync();
@@ -105,7 +101,7 @@ public async Task ShouldSupportTargetFilter()
                     "about:blank",
                     TestConstants.EmptyPage
                 },
-                pages.Select((IPage p) => p.Url).OrderBy(t => t));
+                pages.Select(p => p.Url).OrderBy(t => t));
 
             await page2.CloseAsync();
             await page1.CloseAsync();
@@ -136,7 +132,8 @@ public async Task ShouldBeAbleToReconnectToADisconnectedBrowser()
         {
             var options = new ConnectOptions()
             {
-                BrowserWSEndpoint = Browser.WebSocketEndpoint
+                BrowserWSEndpoint = Browser.WebSocketEndpoint,
+                Protocol = ((Browser)Browser).Protocol,
             };
 
             var url = TestConstants.ServerUrl + "/frames/nested-frames.html";
@@ -161,7 +158,8 @@ public async Task ShouldBeAbleToConnectToTheSamePageSimultaneously()
             var browserOne = await Puppeteer.LaunchAsync(new LaunchOptions());
             var browserTwo = await Puppeteer.ConnectAsync(new ConnectOptions
             {
-                BrowserWSEndpoint = browserOne.WebSocketEndpoint
+                BrowserWSEndpoint = browserOne.WebSocketEndpoint,
+                Protocol = ((Browser)browserOne).Protocol,
             });
             var tcs = new TaskCompletionSource<IPage>();
             async void TargetCreated(object sender, TargetChangedArgs e)
@@ -192,7 +190,8 @@ public async Task ShouldBeAbleToReconnect()
 
             var browserTwo = await Puppeteer.ConnectAsync(new ConnectOptions
             {
-                BrowserWSEndpoint = browserWSEndpoint
+                BrowserWSEndpoint = browserWSEndpoint,
+                Protocol = ((Browser)browserOne).Protocol,
             });
 
             var pages = await browserTwo.PagesAsync();

lib/PuppeteerSharp.Tests/TestConstants.cs

@@ -48,6 +48,7 @@ public static LaunchOptions DefaultBrowserOptions() => new()
             EnqueueAsyncMessages = Convert.ToBoolean(Environment.GetEnvironmentVariable("ENQUEUE_ASYNC_MESSAGES") ?? "false"),
             Timeout = 0,
             LogProcess = true,
+            Protocol = PuppeteerTestAttribute.IsCdp ? ProtocolType.Cdp : ProtocolType.WebdriverBiDi,
 #if NETCOREAPP
             EnqueueTransportMessages = false
 #else
@@ -58,6 +59,7 @@ public static LaunchOptions DefaultBrowserOptions() => new()
         public static LaunchOptions BrowserWithExtensionOptions() => new()
         {
             Headless = false,
+            Protocol = PuppeteerTestAttribute.IsCdp ? ProtocolType.Cdp : ProtocolType.WebdriverBiDi,
             Args = new[]
             {
                 $"--disable-extensions-except={ExtensionPath.Quote()}",

lib/PuppeteerSharp/Browser.cs

@@ -2,9 +2,9 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using System.Net.Sockets;
 using System.Threading.Tasks;
 using PuppeteerSharp.Cdp;
-using PuppeteerSharp.Cdp.Messaging;
 using PuppeteerSharp.Helpers;
 
 namespace PuppeteerSharp
@@ -67,6 +67,8 @@ public abstract class Browser : IBrowser
 
         internal Func<Target, bool> IsPageTargetFunc { get; set; }
 
+        internal abstract ProtocolType Protocol { get; }
+
         /// <inheritdoc/>
         public abstract Task<IPage> NewPageAsync();