Add WindowLog property to BrotliCompressionOptions (#121786)

This PR adds a `WindowLog` property to `BrotliCompressionOptions` to
allow developers to configure the Brotli compression window size (valid
range: 10-24, default: 22). The window log controls the maximum distance
for back-references in the LZ77 algorithm, where larger windows can
improve compression for data with long-distance repetitions. Includes
corresponding validation tests following the existing pattern
established for the `Quality` property.

Fixes #116227

Author: iremyux

src/libraries/System.IO.Compression.Brotli/ref/System.IO.Compression.Brotli.cs

@@ -10,6 +10,7 @@ public sealed partial class BrotliCompressionOptions
     {
         public BrotliCompressionOptions() { }
         public int Quality { get { throw null; } set { } }
+        public int WindowLog { get { throw null; } set { } }
     }
     public partial struct BrotliDecoder : System.IDisposable
     {

src/libraries/System.IO.Compression.Brotli/src/System/IO/Compression/enc/BrotliCompressionOptions.cs

@@ -9,6 +9,7 @@ namespace System.IO.Compression
     public sealed class BrotliCompressionOptions
     {
         private int _quality = BrotliUtils.Quality_Default;
+        private int _windowLog = BrotliUtils.WindowBits_Default;
 
         /// <summary>
         /// Gets or sets the compression quality for a Brotli compression stream.
@@ -28,5 +29,24 @@ public int Quality
                 _quality = value;
             }
         }
+
+        /// <summary>
+        /// Gets or sets the window size for a Brotli compression stream.
+        /// </summary>
+        /// <exception cref="ArgumentOutOfRangeException" accessor="set">The value is less than 10 or greater than 24.</exception>
+        /// <remarks>
+        /// The value is expressed as the base-2 logarithm of the size in bytes of the sliding window used by the LZ77 algorithm. Larger window sizes can improve compression ratio but use more memory. Range is from 10 to 24. The default value is 22.
+        /// </remarks>
+        public int WindowLog
+        {
+            get => _windowLog;
+            set
+            {
+                ArgumentOutOfRangeException.ThrowIfLessThan(value, BrotliUtils.WindowBits_Min, nameof(value));
+                ArgumentOutOfRangeException.ThrowIfGreaterThan(value, BrotliUtils.WindowBits_Max, nameof(value));
+
+                _windowLog = value;
+            }
+        }
     }
 }

src/libraries/System.IO.Compression.Brotli/src/System/IO/Compression/enc/BrotliStream.Compress.cs

@@ -41,6 +41,7 @@ public BrotliStream(Stream stream, BrotliCompressionOptions compressionOptions,
             ArgumentNullException.ThrowIfNull(compressionOptions);
 
             _encoder.SetQuality(compressionOptions.Quality);
+            _encoder.SetWindow(compressionOptions.WindowLog);
         }
 
         /// <summary>Writes compressed bytes to the underlying stream from the specified byte array.</summary>

src/libraries/System.IO.Compression.Brotli/tests/CompressionStreamUnitTests.Brotli.cs

@@ -107,6 +107,52 @@ public void InvalidBrotliCompressionQuality()
             Assert.Throws<ArgumentOutOfRangeException>("value", () => options.Quality = 12);
         }
 
+        [Fact]
+        public void InvalidBrotliCompressionWindowLog()
+        {
+            BrotliCompressionOptions options = new();
+
+            Assert.Equal(22, options.WindowLog); // default value
+            Assert.Throws<ArgumentOutOfRangeException>("value", () => options.WindowLog = -1);
+            Assert.Throws<ArgumentOutOfRangeException>("value", () => options.WindowLog = 9);
+            Assert.Throws<ArgumentOutOfRangeException>("value", () => options.WindowLog = 25);
+        }
+
+        [Theory]
+        [InlineData(10)]
+        [InlineData(15)]
+        [InlineData(22)]
+        [InlineData(24)]
+        public void BrotliCompressionWindowLog_RoundTrip(int windowLog)
+        {
+            byte[] testData = new byte[10000];
+            Random.Shared.NextBytes(testData);
+
+            // Compress with specific window size
+            byte[] compressed;
+            using (var ms = new MemoryStream())
+            {
+                using (var compressor = new BrotliStream(ms, new BrotliCompressionOptions() { WindowLog = windowLog }, leaveOpen: true))
+                {
+                    compressor.Write(testData);
+                }
+                compressed = ms.ToArray();
+            }
+
+            // Decompress and verify
+            byte[] decompressed;
+            using (var ms = new MemoryStream(compressed))
+            using (var decompressor = new BrotliStream(ms, CompressionMode.Decompress))
+            using (var resultStream = new MemoryStream())
+            {
+                decompressor.CopyTo(resultStream);
+                decompressed = resultStream.ToArray();
+            }
+
+            Assert.Equal(testData.Length, decompressed.Length);
+            Assert.Equal<byte>(testData, decompressed);
+        }
+
         [Theory]
         [MemberData(nameof(UncompressedTestFilesBrotli))]
         public async Task BrotliCompressionQuality_SizeInOrder(string testFile)