Remove non-Async versions

src/libraries/System.Net.Quic/ref/System.Net.Quic.cs

@@ -29,8 +29,6 @@ public QuicConnection(System.Net.Quic.QuicClientConnectionOptions options) { }
         public void Dispose() { }
         public int GetRemoteAvailableBidirectionalStreamCount() { throw null; }
         public int GetRemoteAvailableUnidirectionalStreamCount() { throw null; }
-        public System.Net.Quic.QuicStream OpenBidirectionalStream() { throw null; }
-        public System.Net.Quic.QuicStream OpenUnidirectionalStream() { throw null; }
         public System.Threading.Tasks.ValueTask<System.Net.Quic.QuicStream> OpenBidirectionalStreamAsync(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         public System.Threading.Tasks.ValueTask<System.Net.Quic.QuicStream> OpenUnidirectionalStreamAsync(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         public System.Security.Cryptography.X509Certificates.X509Certificate? RemoteCertificate { get { throw null; } }

src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/Mock/MockConnection.cs

@@ -184,52 +184,6 @@ internal override ValueTask WaitForAvailableBidirectionalStreamsAsync(Cancellati
             return streamLimit.Bidirectional.WaitForAvailableStreams(cancellationToken);
         }
 
-        internal override QuicStreamProvider OpenUnidirectionalStream()
-        {
-            PeerStreamLimit? streamLimit = RemoteStreamLimit;
-            if (streamLimit is null)
-            {
-                throw new InvalidOperationException("Not connected");
-            }
-
-            if (!streamLimit.Unidirectional.TryIncrement())
-            {
-                throw new QuicException("No available unidirectional stream");
-            }
-
-            long streamId;
-            lock (_syncObject)
-            {
-                streamId = _nextOutboundUnidirectionalStream;
-                _nextOutboundUnidirectionalStream += 4;
-            }
-
-            return OpenStream(streamId, false);
-        }
-
-        internal override QuicStreamProvider OpenBidirectionalStream()
-        {
-            PeerStreamLimit? streamLimit = RemoteStreamLimit;
-            if (streamLimit is null)
-            {
-                throw new InvalidOperationException("Not connected");
-            }
-
-            if (!streamLimit.Bidirectional.TryIncrement())
-            {
-                throw new QuicException("No available bidirectional stream");
-            }
-
-            long streamId;
-            lock (_syncObject)
-            {
-                streamId = _nextOutboundBidirectionalStream;
-                _nextOutboundBidirectionalStream += 4;
-            }
-
-            return OpenStream(streamId, true);
-        }
-
         internal async override ValueTask<QuicStreamProvider> OpenUnidirectionalStreamAsync(CancellationToken cancellationToken)
         {
             PeerStreamLimit? streamLimit = RemoteStreamLimit;

src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/MsQuicConnection.cs

@@ -582,32 +582,6 @@ internal override ValueTask WaitForAvailableBidirectionalStreamsAsync(Cancellati
             return new ValueTask(tcs.Task.WaitAsync(cancellationToken));
         }
 
-        private QuicStreamProvider OpenStream(QUIC_STREAM_OPEN_FLAGS flags)
-        {
-            ThrowIfDisposed();
-            if (!Connected)
-            {
-                throw new InvalidOperationException(SR.net_quic_not_connected);
-            }
-
-            var stream = new MsQuicStream(_state, flags);
-
-            try
-            {
-                stream.StartAsync(QUIC_STREAM_START_FLAGS.FAIL_BLOCKED | QUIC_STREAM_START_FLAGS.SHUTDOWN_ON_FAIL | QUIC_STREAM_START_FLAGS.INDICATE_PEER_ACCEPT, default).AsTask().GetAwaiter().GetResult();
-            }
-            catch
-            {
-                stream.Dispose();
-                throw;
-            }
-
-            return stream;
-        }
-
-        internal override QuicStreamProvider OpenUnidirectionalStream() => OpenStream(QUIC_STREAM_OPEN_FLAGS.UNIDIRECTIONAL);
-        internal override QuicStreamProvider OpenBidirectionalStream() => OpenStream(QUIC_STREAM_OPEN_FLAGS.NONE);
-
         private async ValueTask<QuicStreamProvider> OpenStreamAsync(QUIC_STREAM_OPEN_FLAGS flags, CancellationToken cancellationToken)
         {
             ThrowIfDisposed();

src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/QuicConnectionProvider.cs

@@ -20,10 +20,6 @@ internal abstract class QuicConnectionProvider : IDisposable
 
         internal abstract ValueTask WaitForAvailableBidirectionalStreamsAsync(CancellationToken cancellationToken = default);
 
-        internal abstract QuicStreamProvider OpenUnidirectionalStream();
-
-        internal abstract QuicStreamProvider OpenBidirectionalStream();
-
         internal abstract ValueTask<QuicStreamProvider> OpenUnidirectionalStreamAsync(CancellationToken cancellationToken = default);
         internal abstract ValueTask<QuicStreamProvider> OpenBidirectionalStreamAsync(CancellationToken cancellationToken = default);
 

src/libraries/System.Net.Quic/src/System/Net/Quic/QuicConnection.cs

@@ -82,18 +82,6 @@ internal QuicConnection(QuicConnectionProvider provider)
         /// <returns></returns>
         public ValueTask WaitForAvailableBidirectionalStreamsAsync(CancellationToken cancellationToken = default) => _provider.WaitForAvailableBidirectionalStreamsAsync(cancellationToken);
 
-        /// <summary>
-        /// Create an outbound unidirectional stream.
-        /// </summary>
-        /// <returns></returns>
-        public QuicStream OpenUnidirectionalStream() => new QuicStream(_provider.OpenUnidirectionalStream());
-
-        /// <summary>
-        /// Create an outbound bidirectional stream.
-        /// </summary>
-        /// <returns></returns>
-        public QuicStream OpenBidirectionalStream() => new QuicStream(_provider.OpenBidirectionalStream());
-
         /// <summary>
         /// Create an outbound unidirectional stream.
         /// </summary>

src/libraries/System.Net.Quic/tests/FunctionalTests/MsQuicTests.cs

@@ -389,7 +389,6 @@ public async Task ConnectWithClientCertificate(bool sendCerttificate)
         }
 
         [Fact]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/67302")]
         public async Task WaitForAvailableUnidirectionStreamsAsyncWorks()
         {
             QuicListenerOptions listenerOptions = CreateQuicListenerOptions();
@@ -400,10 +399,10 @@ public async Task WaitForAvailableUnidirectionStreamsAsyncWorks()
             Assert.True(clientConnection.WaitForAvailableUnidirectionalStreamsAsync().IsCompletedSuccessfully);
 
             // Open one stream, should wait till it closes.
-            QuicStream stream = clientConnection.OpenUnidirectionalStream();
+            QuicStream stream = await clientConnection.OpenUnidirectionalStreamAsync();
             ValueTask waitTask = clientConnection.WaitForAvailableUnidirectionalStreamsAsync();
             Assert.False(waitTask.IsCompleted);
-            Assert.Throws<QuicException>(() => clientConnection.OpenUnidirectionalStream());
+
             // Close the streams, the waitTask should finish as a result.
             stream.Dispose();
             QuicStream newStream = await serverConnection.AcceptStreamAsync();
@@ -425,15 +424,15 @@ public async Task WaitForAvailableBidirectionStreamsAsyncWorks()
             Assert.True(clientConnection.WaitForAvailableBidirectionalStreamsAsync().IsCompletedSuccessfully);
 
             // Open one stream, should wait till it closes.
-            QuicStream stream = clientConnection.OpenBidirectionalStream();
+            QuicStream stream = await clientConnection.OpenBidirectionalStreamAsync();
             ValueTask waitTask = clientConnection.WaitForAvailableBidirectionalStreamsAsync();
             Assert.False(waitTask.IsCompleted);
-            Assert.Throws<QuicException>(() => clientConnection.OpenBidirectionalStream());
 
-            // Close the streams, the waitTask should finish as a result.
+            // Close the streams, the waitTask and nextStreamTask should finish as a result.
             stream.Dispose();
             QuicStream newStream = await serverConnection.AcceptStreamAsync();
             newStream.Dispose();
+
             await waitTask.AsTask().WaitAsync(TimeSpan.FromSeconds(10));
             clientConnection.Dispose();
             serverConnection.Dispose();
@@ -461,7 +460,7 @@ public async Task WriteTests(int[][] writes, WriteType writeType)
             await RunClientServer(
                 async clientConnection =>
                 {
-                    await using QuicStream stream = clientConnection.OpenUnidirectionalStream();
+                    await using QuicStream stream = await clientConnection.OpenUnidirectionalStreamAsync();
 
                     foreach (int[] bufferLengths in writes)
                     {
@@ -554,7 +553,7 @@ public async Task CallDifferentWriteMethodsWorks()
             ReadOnlySequence<byte> ros = CreateReadOnlySequenceFromBytes(helloWorld.ToArray());
 
             Assert.False(ros.IsSingleSegment);
-            using QuicStream clientStream = clientConnection.OpenBidirectionalStream();
+            using QuicStream clientStream = await clientConnection.OpenBidirectionalStreamAsync();
             ValueTask writeTask = clientStream.WriteAsync(ros);
             using QuicStream serverStream = await serverConnection.AcceptStreamAsync();
 
@@ -700,7 +699,7 @@ await RunClientServer(
                     },
                     clientFunction: async connection =>
                     {
-                        await using QuicStream stream = connection.OpenBidirectionalStream();
+                        await using QuicStream stream = await connection.OpenBidirectionalStreamAsync();
 
                         for (int pos = 0; pos < data.Length; pos += writeSize)
                         {
@@ -728,7 +727,7 @@ async Task GetStreamIdWithoutStartWorks()
             {
                 (QuicConnection clientConnection, QuicConnection serverConnection) = await CreateConnectedQuicConnection();
 
-                using QuicStream clientStream = clientConnection.OpenBidirectionalStream();
+                using QuicStream clientStream = await clientConnection.OpenBidirectionalStreamAsync();
                 Assert.Equal(0, clientStream.StreamId);
 
                 // TODO: stream that is opened by client but left unaccepted by server may cause AccessViolationException in its Finalizer
@@ -748,7 +747,7 @@ async Task GetStreamIdWithoutStartWorks()
             {
                 (QuicConnection clientConnection, QuicConnection serverConnection) = await CreateConnectedQuicConnection();
 
-                using QuicStream clientStream = clientConnection.OpenBidirectionalStream();
+                using QuicStream clientStream = await clientConnection.OpenBidirectionalStreamAsync();
                 Assert.Equal(0, clientStream.StreamId);
 
                 // Dispose all connections before the streams;
@@ -770,7 +769,7 @@ await Task.Run(async () =>
             {
                 (QuicConnection clientConnection, QuicConnection serverConnection) = await CreateConnectedQuicConnection();
 
-                await using QuicStream clientStream = clientConnection.OpenBidirectionalStream();
+                await using QuicStream clientStream = await clientConnection.OpenBidirectionalStreamAsync();
                 await clientStream.WriteAsync(new byte[1]);
 
                 await using QuicStream serverStream = await serverConnection.AcceptStreamAsync();
@@ -791,7 +790,7 @@ await Task.Run(async () =>
             {
                 (QuicConnection clientConnection, QuicConnection serverConnection) = await CreateConnectedQuicConnection();
 
-                await using QuicStream clientStream = clientConnection.OpenBidirectionalStream();
+                await using QuicStream clientStream = await clientConnection.OpenBidirectionalStreamAsync();
                 await clientStream.WriteAsync(new byte[1]);
 
                 await using QuicStream serverStream = await serverConnection.AcceptStreamAsync();
@@ -816,7 +815,7 @@ public async Task BigWrite_SmallRead_Success(bool closeWithData)
             {
                 byte[] buffer = new byte[1] { 42 };
 
-                QuicStream clientStream = clientConnection.OpenBidirectionalStream();
+                QuicStream clientStream = await clientConnection.OpenBidirectionalStreamAsync();
                 Task<QuicStream> t = serverConnection.AcceptStreamAsync().AsTask();
                 await TaskTimeoutExtensions.WhenAllOrAnyFailed(clientStream.WriteAsync(buffer).AsTask(), t, PassingTestTimeoutMilliseconds);
                 QuicStream serverStream = t.Result;
@@ -880,7 +879,7 @@ await RunClientServer(
                 },
                 clientFunction: async connection =>
                 {
-                    using QuicStream stream = connection.OpenBidirectionalStream();
+                    using QuicStream stream = await connection.OpenBidirectionalStreamAsync();
                     Assert.False(stream.ReadsCompleted);
 
                     await stream.WriteAsync(s_data, endStream: true);

src/libraries/System.Net.Quic/tests/FunctionalTests/QuicConnectionTests.cs

@@ -42,7 +42,7 @@ public async Task TestConnect()
 
         private static async Task<QuicStream> OpenAndUseStreamAsync(QuicConnection c)
         {
-            QuicStream s = c.OpenBidirectionalStream();
+            QuicStream s = await c.OpenBidirectionalStreamAsync();
 
             // This will pend
             await s.ReadAsync(new byte[1]);
@@ -199,7 +199,7 @@ public async Task CloseAsync_WithOpenStream_LocalAndPeerStreamsFailWithQuicOpera
             await RunClientServer(
                 async clientConnection =>
                 {
-                    using QuicStream clientStream = clientConnection.OpenBidirectionalStream();
+                    using QuicStream clientStream = await clientConnection.OpenBidirectionalStreamAsync();
                     await DoWrites(clientStream, writesBeforeClose);
 
                     // Wait for peer to receive data
@@ -246,7 +246,7 @@ public async Task Dispose_WithOpenLocalStream_LocalStreamFailsWithQuicOperationA
             await RunClientServer(
                 async clientConnection =>
                 {
-                    using QuicStream clientStream = clientConnection.OpenBidirectionalStream();
+                    using QuicStream clientStream = await clientConnection.OpenBidirectionalStreamAsync();
                     await DoWrites(clientStream, writesBeforeClose);
 
                     // Wait for peer to receive data

src/libraries/System.Net.Quic/tests/FunctionalTests/QuicStreamConnectedStreamConformanceTests.cs

@@ -95,7 +95,7 @@ await WhenAllOrAnyFailed(
                             listener.ListenEndPoint,
                             GetSslClientAuthenticationOptions());
                         await connection2.ConnectAsync();
-                        stream2 = connection2.OpenBidirectionalStream();
+                        stream2 = await connection2.OpenBidirectionalStreamAsync();
                         // OpenBidirectionalStream only allocates ID. We will force stream opening
                         // by Writing there and receiving data on the other side.
                         await stream2.WriteAsync(buffer);