PR comments

src/libraries/Common/src/System/Net/Http/HttpHandlerDefaults.cs

@@ -14,7 +14,7 @@ internal static partial class HttpHandlerDefaults
         public const int DefaultMaxAutomaticRedirections = 50;
         public const int DefaultMaxConnectionsPerServer = int.MaxValue;
         public const int DefaultMaxResponseDrainSize = 1024 * 1024;
-        public static readonly TimeSpan DefaultResponseDrainTimeout = TimeSpan.FromTicks(TimeSpan.TicksPerSecond * 2);
+        public static readonly TimeSpan DefaultResponseDrainTimeout = TimeSpan.FromSeconds(2);
         public const int DefaultMaxResponseHeadersLength = 64; // Units in K (1024) bytes.
         public const DecompressionMethods DefaultAutomaticDecompression = DecompressionMethods.None;
         public const bool DefaultAutomaticRedirection = true;
@@ -25,8 +25,8 @@ internal static partial class HttpHandlerDefaults
         public const bool DefaultUseDefaultCredentials = false;
         public const bool DefaultCheckCertificateRevocationList = false;
         public static readonly TimeSpan DefaultPooledConnectionLifetime = Timeout.InfiniteTimeSpan;
-        public static readonly TimeSpan DefaultPooledConnectionIdleTimeout = TimeSpan.FromTicks(TimeSpan.TicksPerMinute * 2);
-        public static readonly TimeSpan DefaultExpect100ContinueTimeout = TimeSpan.FromTicks(TimeSpan.TicksPerSecond * 1);
+        public static readonly TimeSpan DefaultPooledConnectionIdleTimeout = TimeSpan.FromMinutes(2);
+        public static readonly TimeSpan DefaultExpect100ContinueTimeout = TimeSpan.FromSeconds(1);
         public static readonly TimeSpan DefaultConnectTimeout = Timeout.InfiniteTimeSpan;
     }
 }

src/libraries/System.Net.Http/src/System/Net/Http/HttpHandlerDefaults.cs

@@ -10,7 +10,7 @@ namespace System.Net.Http
     /// </summary>
     internal static partial class HttpHandlerDefaults
     {
-        public static readonly TimeSpan DefaultKeepAlivePingTimeout = TimeSpan.FromTicks(TimeSpan.TicksPerSecond * 20);
+        public static readonly TimeSpan DefaultKeepAlivePingTimeout = TimeSpan.FromSeconds(20);
         public static readonly TimeSpan DefaultKeepAlivePingDelay = Timeout.InfiniteTimeSpan;
         public const HttpKeepAlivePingPolicy DefaultKeepAlivePingPolicy = HttpKeepAlivePingPolicy.Always;
     }

src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http2Connection.cs

@@ -134,12 +134,18 @@ public Http2Connection(HttpConnectionPool pool, Connection connection)
             _pendingWindowUpdate = 0;
             _idleSinceTickCount = Environment.TickCount64;
 
-            _keepAlivePingDelay = (long)_pool.Settings._keepAlivePingDelay.TotalMilliseconds;
-            _keepAlivePingTimeout = (long)_pool.Settings._keepAlivePingTimeout.TotalMilliseconds;
+
+            _keepAlivePingDelay = TimeSpanToMs(_pool.Settings._keepAlivePingDelay);
+            _keepAlivePingTimeout = TimeSpanToMs(_pool.Settings._keepAlivePingTimeout);
             _nextPingRequestTimestamp = Environment.TickCount64 + _keepAlivePingDelay;
             _keepAlivePingPolicy = _pool.Settings._keepAlivePingPolicy;
 
             if (NetEventSource.Log.IsEnabled()) TraceConnection(_stream);
+
+            static long TimeSpanToMs(TimeSpan value) {
+                double milliseconds = value.TotalMilliseconds;
+                return (long)(milliseconds > int.MaxValue? int.MaxValue : milliseconds);
+            }
         }
 
         private object SyncObject => _httpStreams;
@@ -1908,9 +1914,9 @@ private void VerifyKeepAlive()
         {
             if (_keepAlivePingPolicy == HttpKeepAlivePingPolicy.WithActiveRequests)
             {
-                lock(SyncObject)
+                lock (SyncObject)
                 {
-                    if(_httpStreams.Count == 0) return;
+                    if (_httpStreams.Count == 0) return;
                 }
             }
 
@@ -1919,7 +1925,7 @@ private void VerifyKeepAlive()
             {
                 case KeepAliveState.None:
                     // Check whether keep alive delay has passed since last frame received
-                    if (now > _nextPingRequestTimestamp && _keepAlivePingDelay != Timeout.InfiniteTimeSpan.TotalMilliseconds)
+                    if (now > _nextPingRequestTimestamp)
                     {
                         // Set the status directly to ping sent and set the timestamp
                         _keepAliveState = KeepAliveState.PingSent;

src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnectionPoolManager.cs

@@ -119,14 +119,16 @@ public HttpConnectionPoolManager(HttpConnectionSettings settings)
                     // For now heart beat is used only for ping functionality.
                     if (_settings._keepAlivePingDelay != Timeout.InfiniteTimeSpan)
                     {
+                        long heartBeatInterval = (long)Math.Max(1000, Math.Min(_settings._keepAlivePingDelay.TotalMilliseconds, _settings._keepAlivePingTimeout.TotalMilliseconds) / 4);
+
                         _heartBeatTimer = new Timer(static state =>
                         {
                             var wr = (WeakReference<HttpConnectionPoolManager>)state!;
                             if (wr.TryGetTarget(out HttpConnectionPoolManager? thisRef))
                             {
                                 thisRef.HeartBeat();
                             }
-                        }, thisRef, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1));
+                        }, thisRef, heartBeatInterval, heartBeatInterval);
                     }
                 }
                 finally

src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/SocketsHttpHandler.cs

@@ -301,7 +301,7 @@ public TimeSpan KeepAlivePingDelay
                 }
 
                 CheckDisposedOrStarted();
-                _settings._keepAlivePingDelay = value.TotalMilliseconds > int.MaxValue? TimeSpan.FromMilliseconds(int.MaxValue) : value;
+                _settings._keepAlivePingDelay = value;
             }
         }
 
@@ -326,7 +326,7 @@ public TimeSpan KeepAlivePingTimeout
                 }
 
                 CheckDisposedOrStarted();
-                _settings._keepAlivePingTimeout = value.TotalMilliseconds > int.MaxValue? TimeSpan.FromMilliseconds(int.MaxValue) : value;
+                _settings._keepAlivePingTimeout = value;
             }
         }
 

src/libraries/System.Net.Http/tests/FunctionalTests/SocketsHttpHandlerTest.cs

@@ -304,21 +304,6 @@ public void SettersExceptions()
             Assert.Throws<ArgumentOutOfRangeException>(() => handler.KeepAlivePingTimeout = TimeSpan.FromMilliseconds(500));
         }
 
-        [Theory]
-        [InlineData(1000, 1000)]
-        [InlineData(int.MaxValue - 1, int.MaxValue - 1)]
-        [InlineData(int.MaxValue, int.MaxValue)]
-        // Setter starts clamp the value
-        [InlineData((double)int.MaxValue + 1, (double)int.MaxValue)]
-        public void Setters(double milliseconds, double expectedMilliseconds)
-        {
-            using var handler = new SocketsHttpHandler();
-
-            handler.KeepAlivePingTimeout = TimeSpan.FromMilliseconds(milliseconds);
-            Assert.Equal(TimeSpan.FromMilliseconds(expectedMilliseconds), handler.KeepAlivePingTimeout);
-        }
-
-
         public static IEnumerable<object[]> KeepAliveTestDataSource()
         {
             yield return new object[] { Timeout.InfiniteTimeSpan, TimeSpan.FromSeconds(0), HttpKeepAlivePingPolicy.Always, false, false, false };