diff --git a/quiche/quic/core/quic_connection.cc b/quiche/quic/core/quic_connection.cc
index 44a7830..82b07cc 100644
--- a/quiche/quic/core/quic_connection.cc
+++ b/quiche/quic/core/quic_connection.cc
@@ -128,6 +128,7 @@
 
   void OnAlarm() override {
     QUICHE_DCHECK(connection_->connected());
+    QUICHE_DCHECK(!GetQuicReloadableFlag(quic_use_ping_manager));
     connection_->OnPingTimeout();
   }
 };
@@ -327,7 +328,8 @@
                              alarm_factory_, &context_),
       path_validator_(alarm_factory_, &arena_, this, random_generator_,
                       &context_),
-      most_recent_frame_type_(NUM_FRAME_TYPES) {
+      most_recent_frame_type_(NUM_FRAME_TYPES),
+      ping_manager_(perspective, this, &arena_, alarm_factory_, &context_) {
   QUICHE_DCHECK(perspective_ == Perspective::IS_CLIENT ||
                 default_path_.self_address.IsInitialized());
 
@@ -1350,7 +1352,11 @@
   MaybeUpdateAckTimeout();
   visitor_->OnStreamFrame(frame);
   stats_.stream_bytes_received += frame.data_length;
-  consecutive_retransmittable_on_wire_ping_count_ = 0;
+  if (use_ping_manager_) {
+    ping_manager_.reset_consecutive_retransmittable_on_wire_count();
+  } else {
+    consecutive_retransmittable_on_wire_ping_count_ = 0;
+  }
   return connected_;
 }
 
@@ -4053,6 +4059,7 @@
 }
 
 void QuicConnection::OnPingTimeout() {
+  QUICHE_DCHECK(!use_ping_manager_);
   if (retransmission_alarm_->IsSet() ||
       !visitor_->ShouldKeepConnectionAlive()) {
     return;
@@ -4621,7 +4628,11 @@
   QUIC_DVLOG(1) << "Cancelling all QuicConnection alarms.";
 
   ack_alarm_->PermanentCancel();
-  ping_alarm_->PermanentCancel();
+  if (use_ping_manager_) {
+    ping_manager_.Stop();
+  } else {
+    ping_alarm_->PermanentCancel();
+  }
   retransmission_alarm_->PermanentCancel();
   send_alarm_->PermanentCancel();
   mtu_discovery_alarm_->PermanentCancel();
@@ -4665,6 +4676,13 @@
   if (!connected_) {
     return;
   }
+  if (use_ping_manager_) {
+    QUIC_RELOADABLE_FLAG_COUNT(quic_use_ping_manager);
+    ping_manager_.SetAlarm(clock_->ApproximateNow(),
+                           visitor_->ShouldKeepConnectionAlive(),
+                           sent_packet_manager_.HasInFlightPackets());
+    return;
+  }
   if (perspective_ == Perspective::IS_SERVER &&
       initial_retransmittable_on_wire_timeout_.IsInfinite()) {
     // The PING alarm exists to support two features:
@@ -6280,6 +6298,24 @@
                   idle_timeout_connection_close_behavior_);
 }
 
+void QuicConnection::OnKeepAliveTimeout() {
+  QUICHE_DCHECK(use_ping_manager_);
+  if (retransmission_alarm_->IsSet() ||
+      !visitor_->ShouldKeepConnectionAlive()) {
+    return;
+  }
+  SendPingAtLevel(framer().GetEncryptionLevelToSendApplicationData());
+}
+
+void QuicConnection::OnRetransmittableOnWireTimeout() {
+  QUICHE_DCHECK(use_ping_manager_);
+  if (retransmission_alarm_->IsSet() ||
+      !visitor_->ShouldKeepConnectionAlive()) {
+    return;
+  }
+  SendPingAtLevel(framer().GetEncryptionLevelToSendApplicationData());
+}
+
 void QuicConnection::OnPeerIssuedConnectionIdRetired() {
   QUICHE_DCHECK(peer_issued_cid_manager_ != nullptr);
   QuicConnectionId* default_path_cid =
@@ -7107,5 +7143,26 @@
   return old_send_algorithm;
 }
 
+void QuicConnection::set_keep_alive_ping_timeout(
+    QuicTime::Delta keep_alive_ping_timeout) {
+  if (use_ping_manager_) {
+    ping_manager_.set_keep_alive_timeout(keep_alive_ping_timeout);
+    return;
+  }
+  QUICHE_DCHECK(!ping_alarm_->IsSet());
+  keep_alive_ping_timeout_ = keep_alive_ping_timeout;
+}
+
+void QuicConnection::set_initial_retransmittable_on_wire_timeout(
+    QuicTime::Delta retransmittable_on_wire_timeout) {
+  if (use_ping_manager_) {
+    ping_manager_.set_initial_retransmittable_on_wire_timeout(
+        retransmittable_on_wire_timeout);
+    return;
+  }
+  QUICHE_DCHECK(!ping_alarm_->IsSet());
+  initial_retransmittable_on_wire_timeout_ = retransmittable_on_wire_timeout;
+}
+
 #undef ENDPOINT  // undef for jumbo builds
 }  // namespace quic
diff --git a/quiche/quic/core/quic_connection.h b/quiche/quic/core/quic_connection.h
index 6aca00b..9c93dd4 100644
--- a/quiche/quic/core/quic_connection.h
+++ b/quiche/quic/core/quic_connection.h
@@ -50,6 +50,7 @@
 #include "quiche/quic/core/quic_packet_writer.h"
 #include "quiche/quic/core/quic_packets.h"
 #include "quiche/quic/core/quic_path_validator.h"
+#include "quiche/quic/core/quic_ping_manager.h"
 #include "quiche/quic/core/quic_sent_packet_manager.h"
 #include "quiche/quic/core/quic_time.h"
 #include "quiche/quic/core/quic_types.h"
@@ -458,7 +459,8 @@
       public QuicNetworkBlackholeDetector::Delegate,
       public QuicIdleNetworkDetector::Delegate,
       public QuicPathValidator::SendDelegate,
-      public QuicConnectionIdManagerVisitorInterface {
+      public QuicConnectionIdManagerVisitorInterface,
+      public QuicPingManager::Delegate {
  public:
   // Constructs a new QuicConnection for |connection_id| and
   // |initial_peer_address| using |writer| to write packets. |owns_writer|
@@ -710,6 +712,10 @@
   void OnHandshakeTimeout() override;
   void OnIdleNetworkDetected() override;
 
+  // QuicPingManager::Delegate
+  void OnKeepAliveTimeout() override;
+  void OnRetransmittableOnWireTimeout() override;
+
   // QuicConnectionIdManagerVisitorInterface
   void OnPeerIssuedConnectionIdRetired() override;
   bool SendNewConnectionId(const QuicNewConnectionIdFrame& frame) override;
@@ -741,17 +747,11 @@
   }
   // Used in Chromium, but not internally.
   // Must only be called before ping_alarm_ is set.
-  void set_keep_alive_ping_timeout(QuicTime::Delta keep_alive_ping_timeout) {
-    QUICHE_DCHECK(!ping_alarm_->IsSet());
-    keep_alive_ping_timeout_ = keep_alive_ping_timeout;
-  }
+  void set_keep_alive_ping_timeout(QuicTime::Delta keep_alive_ping_timeout);
   // Sets an initial timeout for the ping alarm when there is no retransmittable
   // data in flight, allowing for a more aggressive ping alarm in that case.
   void set_initial_retransmittable_on_wire_timeout(
-      QuicTime::Delta retransmittable_on_wire_timeout) {
-    QUICHE_DCHECK(!ping_alarm_->IsSet());
-    initial_retransmittable_on_wire_timeout_ = retransmittable_on_wire_timeout;
-  }
+      QuicTime::Delta retransmittable_on_wire_timeout);
   // Used in Chromium, but not internally.
   void set_creator_debug_delegate(QuicPacketCreator::DebugDelegate* visitor) {
     packet_creator_.set_debug_delegate(visitor);
@@ -1976,6 +1976,8 @@
   // SendAlarm.
   bool defer_send_in_response_to_packets_;
 
+  // TODO(fayang): remove PING related fields below when deprecating
+  // quic_use_ping_manager.
   // The timeout for keep-alive PING.
   QuicTime::Delta keep_alive_ping_timeout_;
 
@@ -1999,6 +2001,7 @@
   // An alarm that is scheduled when the SentPacketManager requires a delay
   // before sending packets and fires when the packet may be sent.
   QuicArenaScopedPtr<QuicAlarm> send_alarm_;
+  // TODO(fayang): remove ping_alarm_ when deprecating quic_use_ping_manager.
   // An alarm that fires when a ping should be sent.
   QuicArenaScopedPtr<QuicAlarm> ping_alarm_;
   // An alarm that fires when an MTU probe should be sent.
@@ -2247,6 +2250,10 @@
   // If true, send connection close packet on INVALID_VERSION.
   bool send_connection_close_for_invalid_version_ = false;
 
+  const bool use_ping_manager_ = GetQuicReloadableFlag(quic_use_ping_manager);
+
+  QuicPingManager ping_manager_;
+
   // TODO(b/205023946) Debug-only fields, to be deprecated after the bug is
   // fixed.
   absl::optional<QuicWallTime> quic_bug_10511_43_timestamp_;
diff --git a/quiche/quic/core/quic_flags_list.h b/quiche/quic/core/quic_flags_list.h
index 085f9d3..bfc2462 100644
--- a/quiche/quic/core/quic_flags_list.h
+++ b/quiche/quic/core/quic_flags_list.h
@@ -93,6 +93,8 @@
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_update_ack_timeout_on_receipt_time, true)
 // If true, use BBRv2 as the default congestion controller. Takes precedence over --quic_default_to_bbr.
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_default_to_bbr_v2, false)
+// If true, use PING manager to manage the PING alarm.
+QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_use_ping_manager, true)
 // If true, use new connection ID in connection migration.
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_connection_migration_use_new_cid_v2, true)
 // If true, uses conservative cwnd gain and pacing gain when cwnd gets bootstrapped.
diff --git a/quiche/quic/core/quic_one_block_arena.h b/quiche/quic/core/quic_one_block_arena.h
index 4bebebe..05d335b 100644
--- a/quiche/quic/core/quic_one_block_arena.h
+++ b/quiche/quic/core/quic_one_block_arena.h
@@ -69,7 +69,7 @@
 
 // QuicConnections currently use around 1KB of polymorphic types which would
 // ordinarily be on the heap. Instead, store them inline in an arena.
-using QuicConnectionArena = QuicOneBlockArena<1152>;
+using QuicConnectionArena = QuicOneBlockArena<1248>;
 
 }  // namespace quic
 
diff --git a/quiche/quic/core/quic_ping_manager.cc b/quiche/quic/core/quic_ping_manager.cc
new file mode 100644
index 0000000..7ce158d
--- /dev/null
+++ b/quiche/quic/core/quic_ping_manager.cc
@@ -0,0 +1,158 @@
+// Copyright (c) 2022 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/core/quic_ping_manager.h"
+
+namespace quic {
+
+namespace {
+
+class AlarmDelegate : public QuicAlarm::DelegateWithContext {
+ public:
+  explicit AlarmDelegate(QuicPingManager* manager,
+                         QuicConnectionContext* context)
+      : QuicAlarm::DelegateWithContext(context), manager_(manager) {}
+  AlarmDelegate(const AlarmDelegate&) = delete;
+  AlarmDelegate& operator=(const AlarmDelegate&) = delete;
+
+  void OnAlarm() override { manager_->OnAlarm(); }
+
+ private:
+  QuicPingManager* manager_;
+};
+
+}  // namespace
+
+QuicPingManager::QuicPingManager(Perspective perspective, Delegate* delegate,
+                                 QuicConnectionArena* arena,
+                                 QuicAlarmFactory* alarm_factory,
+                                 QuicConnectionContext* context)
+    : perspective_(perspective),
+      delegate_(delegate),
+      alarm_(alarm_factory->CreateAlarm(
+          arena->New<AlarmDelegate>(this, context), arena)) {}
+
+void QuicPingManager::SetAlarm(QuicTime now, bool should_keep_alive,
+                               bool has_in_flight_packets) {
+  UpdateDeadlines(now, should_keep_alive, has_in_flight_packets);
+  const QuicTime earliest_deadline = GetEarliestDeadline();
+  if (!earliest_deadline.IsInitialized()) {
+    alarm_->Cancel();
+    return;
+  }
+  if (earliest_deadline == keep_alive_deadline_) {
+    // Use 1s granularity for keep-alive time.
+    alarm_->Update(earliest_deadline, QuicTime::Delta::FromSeconds(1));
+    return;
+  }
+  alarm_->Update(earliest_deadline, kAlarmGranularity);
+  if (GetQuicFlag(
+          FLAGS_quic_max_aggressive_retransmittable_on_wire_ping_count) != 0) {
+    ++consecutive_retransmittable_on_wire_count_;
+  }
+  ++retransmittable_on_wire_count_;
+}
+
+void QuicPingManager::OnAlarm() {
+  const QuicTime earliest_deadline = GetEarliestDeadline();
+  if (!earliest_deadline.IsInitialized()) {
+    QUIC_BUG(quic_ping_manager_alarm_fires_unexpectedly)
+        << "QuicPingManager alarm fires unexpectedly.";
+    return;
+  }
+  // Please note, alarm does not get re-armed here, and we are relying on caller
+  // to SetAlarm later.
+  if (earliest_deadline == retransmittable_on_wire_deadline_) {
+    retransmittable_on_wire_deadline_ = QuicTime::Zero();
+    delegate_->OnRetransmittableOnWireTimeout();
+    return;
+  }
+  if (earliest_deadline == keep_alive_deadline_) {
+    keep_alive_deadline_ = QuicTime::Zero();
+    delegate_->OnKeepAliveTimeout();
+  }
+}
+
+void QuicPingManager::Stop() {
+  alarm_->PermanentCancel();
+  retransmittable_on_wire_deadline_ = QuicTime::Zero();
+  keep_alive_deadline_ = QuicTime::Zero();
+}
+
+void QuicPingManager::UpdateDeadlines(QuicTime now, bool should_keep_alive,
+                                      bool has_in_flight_packets) {
+  // Reset keep-alive deadline given it will be set later (with left edge
+  // |now|).
+  keep_alive_deadline_ = QuicTime::Zero();
+  if (perspective_ == Perspective::IS_SERVER &&
+      initial_retransmittable_on_wire_timeout_.IsInfinite()) {
+    // The PING alarm exists to support two features:
+    // 1) clients send PINGs every 15s to prevent NAT timeouts,
+    // 2) both clients and servers can send retransmittable on the wire PINGs
+    // (ROWP) while ShouldKeepConnectionAlive is true and there is no packets in
+    // flight.
+    QUICHE_DCHECK(!retransmittable_on_wire_deadline_.IsInitialized());
+    return;
+  }
+  if (!should_keep_alive) {
+    // Don't send a ping unless the application (ie: HTTP/3) says to, usually
+    // because it is expecting a response from the peer.
+    retransmittable_on_wire_deadline_ = QuicTime::Zero();
+    return;
+  }
+  if (perspective_ == Perspective::IS_CLIENT) {
+    // Clients send 15s PINGs to avoid NATs from timing out.
+    keep_alive_deadline_ = now + keep_alive_timeout_;
+  }
+  if (initial_retransmittable_on_wire_timeout_.IsInfinite() ||
+      has_in_flight_packets ||
+      retransmittable_on_wire_count_ >
+          GetQuicFlag(FLAGS_quic_max_retransmittable_on_wire_ping_count)) {
+    // No need to set retransmittable-on-wire timeout.
+    retransmittable_on_wire_deadline_ = QuicTime::Zero();
+    return;
+  }
+
+  QUICHE_DCHECK_LT(initial_retransmittable_on_wire_timeout_,
+                   keep_alive_timeout_);
+  QuicTime::Delta retransmittable_on_wire_timeout =
+      initial_retransmittable_on_wire_timeout_;
+  const int max_aggressive_retransmittable_on_wire_count =
+      GetQuicFlag(FLAGS_quic_max_aggressive_retransmittable_on_wire_ping_count);
+  QUICHE_DCHECK_LE(0, max_aggressive_retransmittable_on_wire_count);
+  if (consecutive_retransmittable_on_wire_count_ >
+      max_aggressive_retransmittable_on_wire_count) {
+    // Exponentially back off the timeout if the number of consecutive
+    // retransmittable on wire pings has exceeds the allowance.
+    int shift = consecutive_retransmittable_on_wire_count_ -
+                max_aggressive_retransmittable_on_wire_count;
+    retransmittable_on_wire_timeout =
+        initial_retransmittable_on_wire_timeout_ * (1 << shift);
+  }
+  if (retransmittable_on_wire_deadline_.IsInitialized() &&
+      retransmittable_on_wire_deadline_ <
+          now + retransmittable_on_wire_timeout) {
+    // Alarm is set to an earlier time. Do not postpone it.
+    QUIC_BUG_IF(quic_retransmittable_on_wire_deadline_is_in_past,
+                retransmittable_on_wire_deadline_ < now)
+        << "QUIC retransmittable PING deadline is in past";
+    return;
+  }
+  retransmittable_on_wire_deadline_ = now + retransmittable_on_wire_timeout;
+}
+
+QuicTime QuicPingManager::GetEarliestDeadline() const {
+  QuicTime earliest_deadline = QuicTime::Zero();
+  for (QuicTime t : {retransmittable_on_wire_deadline_, keep_alive_deadline_}) {
+    if (!t.IsInitialized()) {
+      continue;
+    }
+    if (!earliest_deadline.IsInitialized() || t < earliest_deadline) {
+      earliest_deadline = t;
+    }
+  }
+  return earliest_deadline;
+}
+
+}  // namespace quic
diff --git a/quiche/quic/core/quic_ping_manager.h b/quiche/quic/core/quic_ping_manager.h
new file mode 100644
index 0000000..d88dac2
--- /dev/null
+++ b/quiche/quic/core/quic_ping_manager.h
@@ -0,0 +1,108 @@
+// Copyright (c) 2022 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_CORE_QUIC_PING_MANAGER_H_
+#define QUICHE_QUIC_CORE_QUIC_PING_MANAGER_H_
+
+#include "quiche/quic/core/quic_alarm.h"
+#include "quiche/quic/core/quic_alarm_factory.h"
+#include "quiche/quic/core/quic_constants.h"
+#include "quiche/quic/core/quic_one_block_arena.h"
+#include "quiche/quic/core/quic_time.h"
+#include "quiche/quic/platform/api/quic_export.h"
+
+namespace quic {
+
+namespace test {
+class QuicConnectionPeer;
+class QuicPingManagerPeer;
+}  // namespace test
+
+// QuicPingManager manages an alarm that has two modes:
+// 1) keep-alive. When alarm fires, send packet to extend idle timeout to keep
+// connection alive.
+// 2) retransmittable-on-wire. When alarm fires, send packets to detect path
+// degrading (used in IP/port migrations).
+class QUIC_EXPORT_PRIVATE QuicPingManager {
+ public:
+  // Interface that get notified when |alarm_| fires.
+  class QUIC_EXPORT_PRIVATE Delegate {
+   public:
+    virtual ~Delegate() {}
+
+    // Called when alarm fires in keep-alive mode.
+    virtual void OnKeepAliveTimeout() = 0;
+    // Called when alarm fires in retransmittable-on-wire mode.
+    virtual void OnRetransmittableOnWireTimeout() = 0;
+  };
+
+  QuicPingManager(Perspective perspective, Delegate* delegate,
+                  QuicConnectionArena* arena, QuicAlarmFactory* alarm_factory,
+                  QuicConnectionContext* context);
+
+  // Called to set |alarm_|.
+  void SetAlarm(QuicTime now, bool should_keep_alive,
+                bool has_in_flight_packets);
+
+  // Called when |alarm_| fires.
+  void OnAlarm();
+
+  // Called to stop |alarm_| permanently.
+  void Stop();
+
+  void set_keep_alive_timeout(QuicTime::Delta keep_alive_timeout) {
+    QUICHE_DCHECK(!alarm_->IsSet());
+    keep_alive_timeout_ = keep_alive_timeout;
+  }
+
+  void set_initial_retransmittable_on_wire_timeout(
+      QuicTime::Delta retransmittable_on_wire_timeout) {
+    QUICHE_DCHECK(!alarm_->IsSet());
+    initial_retransmittable_on_wire_timeout_ = retransmittable_on_wire_timeout;
+  }
+
+  void reset_consecutive_retransmittable_on_wire_count() {
+    consecutive_retransmittable_on_wire_count_ = 0;
+  }
+
+ private:
+  friend class test::QuicConnectionPeer;
+  friend class test::QuicPingManagerPeer;
+
+  // Update |retransmittable_on_wire_deadline_| and |keep_alive_deadline_|.
+  void UpdateDeadlines(QuicTime now, bool should_keep_alive,
+                       bool has_in_flight_packets);
+
+  // Get earliest deadline of |retransmittable_on_wire_deadline_| and
+  // |keep_alive_deadline_|. Returns 0 if both deadlines are not initialized.
+  QuicTime GetEarliestDeadline() const;
+
+  Perspective perspective_;
+
+  Delegate* delegate_;  // Not owned.
+
+  // Initial timeout for how long the wire can have no retransmittable packets.
+  QuicTime::Delta initial_retransmittable_on_wire_timeout_ =
+      QuicTime::Delta::Infinite();
+
+  // Indicates how many consecutive retransmittable-on-wire has been armed
+  // (since last reset).
+  int consecutive_retransmittable_on_wire_count_ = 0;
+
+  // Indicates how many retransmittable-on-wire has been armed in total.
+  int retransmittable_on_wire_count_ = 0;
+
+  QuicTime::Delta keep_alive_timeout_ =
+      QuicTime::Delta::FromSeconds(kPingTimeoutSecs);
+
+  QuicTime retransmittable_on_wire_deadline_ = QuicTime::Zero();
+
+  QuicTime keep_alive_deadline_ = QuicTime::Zero();
+
+  QuicArenaScopedPtr<QuicAlarm> alarm_;
+};
+
+}  // namespace quic
+
+#endif  // QUICHE_QUIC_CORE_QUIC_PING_MANAGER_H_
diff --git a/quiche/quic/core/quic_ping_manager_test.cc b/quiche/quic/core/quic_ping_manager_test.cc
new file mode 100644
index 0000000..e7b4b78
--- /dev/null
+++ b/quiche/quic/core/quic_ping_manager_test.cc
@@ -0,0 +1,381 @@
+// Copyright (c) 2022 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/core/quic_ping_manager.h"
+
+#include "quiche/quic/core/quic_one_block_arena.h"
+#include "quiche/quic/platform/api/quic_test.h"
+#include "quiche/quic/test_tools/quic_test_utils.h"
+
+namespace quic {
+namespace test {
+
+class QuicPingManagerPeer {
+ public:
+  static QuicAlarm* GetAlarm(QuicPingManager* manager) {
+    return manager->alarm_.get();
+  }
+};
+
+namespace {
+
+const bool kShouldKeepAlive = true;
+const bool kHasInflightPackets = true;
+
+class MockDelegate : public QuicPingManager::Delegate {
+ public:
+  MOCK_METHOD(void, OnKeepAliveTimeout, (), (override));
+  MOCK_METHOD(void, OnRetransmittableOnWireTimeout, (), (override));
+};
+
+class QuicPingManagerTest : public QuicTest {
+ public:
+  QuicPingManagerTest()
+      : manager_(Perspective::IS_CLIENT, &delegate_, &arena_, &alarm_factory_,
+                 /*context=*/nullptr),
+        alarm_(static_cast<MockAlarmFactory::TestAlarm*>(
+            QuicPingManagerPeer::GetAlarm(&manager_))) {
+    clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
+  }
+
+ protected:
+  testing::StrictMock<MockDelegate> delegate_;
+  MockClock clock_;
+  QuicConnectionArena arena_;
+  MockAlarmFactory alarm_factory_;
+  QuicPingManager manager_;
+  MockAlarmFactory::TestAlarm* alarm_;
+};
+
+TEST_F(QuicPingManagerTest, KeepAliveTimeout) {
+  EXPECT_FALSE(alarm_->IsSet());
+
+  clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
+  // Set alarm with in flight packets.
+  manager_.SetAlarm(clock_.ApproximateNow(), kShouldKeepAlive,
+                    kHasInflightPackets);
+  EXPECT_TRUE(alarm_->IsSet());
+  EXPECT_EQ(QuicTime::Delta::FromSeconds(kPingTimeoutSecs),
+            alarm_->deadline() - clock_.ApproximateNow());
+
+  clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
+  // Reset alarm with no in flight packets.
+  manager_.SetAlarm(clock_.ApproximateNow(), kShouldKeepAlive,
+                    !kHasInflightPackets);
+  EXPECT_TRUE(alarm_->IsSet());
+  // Verify the deadline is set slightly less than 15 seconds in the future,
+  // because of the 1s alarm granularity.
+  EXPECT_EQ(QuicTime::Delta::FromSeconds(kPingTimeoutSecs) -
+                QuicTime::Delta::FromMilliseconds(5),
+            alarm_->deadline() - clock_.ApproximateNow());
+
+  clock_.AdvanceTime(QuicTime::Delta::FromSeconds(kPingTimeoutSecs));
+  EXPECT_CALL(delegate_, OnKeepAliveTimeout());
+  alarm_->Fire();
+  EXPECT_FALSE(alarm_->IsSet());
+  // Reset alarm with in flight packets.
+  manager_.SetAlarm(clock_.ApproximateNow(), kShouldKeepAlive,
+                    kHasInflightPackets);
+  EXPECT_TRUE(alarm_->IsSet());
+
+  // Verify alarm is not armed if !kShouldKeepAlive.
+  clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
+  manager_.SetAlarm(clock_.ApproximateNow(), !kShouldKeepAlive,
+                    kHasInflightPackets);
+  EXPECT_FALSE(alarm_->IsSet());
+}
+
+TEST_F(QuicPingManagerTest, CustomizedKeepAliveTimeout) {
+  EXPECT_FALSE(alarm_->IsSet());
+
+  // Set customized keep-alive timeout.
+  manager_.set_keep_alive_timeout(QuicTime::Delta::FromSeconds(10));
+
+  clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
+  // Set alarm with in flight packets.
+  manager_.SetAlarm(clock_.ApproximateNow(), kShouldKeepAlive,
+                    kHasInflightPackets);
+  EXPECT_TRUE(alarm_->IsSet());
+  EXPECT_EQ(QuicTime::Delta::FromSeconds(10),
+            alarm_->deadline() - clock_.ApproximateNow());
+
+  clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
+  // Set alarm with no in flight packets.
+  manager_.SetAlarm(clock_.ApproximateNow(), kShouldKeepAlive,
+                    !kHasInflightPackets);
+  EXPECT_TRUE(alarm_->IsSet());
+  // The deadline is set slightly less than 10 seconds in the future, because
+  // of the 1s alarm granularity.
+  EXPECT_EQ(
+      QuicTime::Delta::FromSeconds(10) - QuicTime::Delta::FromMilliseconds(5),
+      alarm_->deadline() - clock_.ApproximateNow());
+
+  clock_.AdvanceTime(QuicTime::Delta::FromSeconds(10));
+  EXPECT_CALL(delegate_, OnKeepAliveTimeout());
+  alarm_->Fire();
+  EXPECT_FALSE(alarm_->IsSet());
+  // Reset alarm with in flight packets.
+  manager_.SetAlarm(clock_.ApproximateNow(), kShouldKeepAlive,
+                    kHasInflightPackets);
+  EXPECT_TRUE(alarm_->IsSet());
+
+  // Verify alarm is not armed if !kShouldKeepAlive.
+  clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
+  manager_.SetAlarm(clock_.ApproximateNow(), !kShouldKeepAlive,
+                    kHasInflightPackets);
+  EXPECT_FALSE(alarm_->IsSet());
+}
+
+TEST_F(QuicPingManagerTest, RetransmittableOnWireTimeout) {
+  const QuicTime::Delta kRtransmittableOnWireTimeout =
+      QuicTime::Delta::FromMilliseconds(50);
+  manager_.set_initial_retransmittable_on_wire_timeout(
+      kRtransmittableOnWireTimeout);
+
+  EXPECT_FALSE(alarm_->IsSet());
+
+  // Set alarm with in flight packets.
+  manager_.SetAlarm(clock_.ApproximateNow(), kShouldKeepAlive,
+                    kHasInflightPackets);
+  // Verify alarm is in keep-alive mode.
+  EXPECT_TRUE(alarm_->IsSet());
+  EXPECT_EQ(QuicTime::Delta::FromSeconds(kPingTimeoutSecs),
+            alarm_->deadline() - clock_.ApproximateNow());
+
+  clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
+  // Set alarm with no in flight packets.
+  manager_.SetAlarm(clock_.ApproximateNow(), kShouldKeepAlive,
+                    !kHasInflightPackets);
+  EXPECT_TRUE(alarm_->IsSet());
+  // Verify alarm is in retransmittable-on-wire mode.
+  EXPECT_EQ(kRtransmittableOnWireTimeout,
+            alarm_->deadline() - clock_.ApproximateNow());
+
+  clock_.AdvanceTime(kRtransmittableOnWireTimeout);
+  EXPECT_CALL(delegate_, OnRetransmittableOnWireTimeout());
+  alarm_->Fire();
+  EXPECT_FALSE(alarm_->IsSet());
+  // Reset alarm with in flight packets.
+  manager_.SetAlarm(clock_.ApproximateNow(), kShouldKeepAlive,
+                    kHasInflightPackets);
+  // Verify the alarm is in keep-alive mode.
+  ASSERT_TRUE(alarm_->IsSet());
+  EXPECT_EQ(QuicTime::Delta::FromSeconds(kPingTimeoutSecs),
+            alarm_->deadline() - clock_.ApproximateNow());
+}
+
+TEST_F(QuicPingManagerTest, RetransmittableOnWireTimeoutExponentiallyBackOff) {
+  const int kMaxAggressiveRetransmittableOnWireCount = 5;
+  SetQuicFlag(FLAGS_quic_max_aggressive_retransmittable_on_wire_ping_count,
+              kMaxAggressiveRetransmittableOnWireCount);
+  const QuicTime::Delta initial_retransmittable_on_wire_timeout =
+      QuicTime::Delta::FromMilliseconds(200);
+  manager_.set_initial_retransmittable_on_wire_timeout(
+      initial_retransmittable_on_wire_timeout);
+
+  clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
+  EXPECT_FALSE(alarm_->IsSet());
+  manager_.SetAlarm(clock_.ApproximateNow(), kShouldKeepAlive,
+                    kHasInflightPackets);
+  // Verify alarm is in keep-alive mode.
+  EXPECT_TRUE(alarm_->IsSet());
+  EXPECT_EQ(QuicTime::Delta::FromSeconds(kPingTimeoutSecs),
+            alarm_->deadline() - clock_.ApproximateNow());
+
+  // Verify no exponential backoff on the first few retransmittable on wire
+  // timeouts.
+  for (int i = 0; i <= kMaxAggressiveRetransmittableOnWireCount; ++i) {
+    clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
+    // Reset alarm with no in flight packets.
+    manager_.SetAlarm(clock_.ApproximateNow(), kShouldKeepAlive,
+                      !kHasInflightPackets);
+    EXPECT_TRUE(alarm_->IsSet());
+    // Verify alarm is in retransmittable-on-wire mode.
+    EXPECT_EQ(initial_retransmittable_on_wire_timeout,
+              alarm_->deadline() - clock_.ApproximateNow());
+    clock_.AdvanceTime(initial_retransmittable_on_wire_timeout);
+    EXPECT_CALL(delegate_, OnRetransmittableOnWireTimeout());
+    alarm_->Fire();
+    EXPECT_FALSE(alarm_->IsSet());
+    // Reset alarm with in flight packets.
+    manager_.SetAlarm(clock_.ApproximateNow(), kShouldKeepAlive,
+                      kHasInflightPackets);
+  }
+
+  QuicTime::Delta retransmittable_on_wire_timeout =
+      initial_retransmittable_on_wire_timeout;
+
+  // Verify subsequent retransmittable-on-wire timeout is exponentially backed
+  // off.
+  while (retransmittable_on_wire_timeout * 2 <
+         QuicTime::Delta::FromSeconds(kPingTimeoutSecs)) {
+    retransmittable_on_wire_timeout = retransmittable_on_wire_timeout * 2;
+    clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
+    manager_.SetAlarm(clock_.ApproximateNow(), kShouldKeepAlive,
+                      !kHasInflightPackets);
+    EXPECT_TRUE(alarm_->IsSet());
+    EXPECT_EQ(retransmittable_on_wire_timeout,
+              alarm_->deadline() - clock_.ApproximateNow());
+
+    clock_.AdvanceTime(retransmittable_on_wire_timeout);
+    EXPECT_CALL(delegate_, OnRetransmittableOnWireTimeout());
+    alarm_->Fire();
+    EXPECT_FALSE(alarm_->IsSet());
+    // Reset alarm with in flight packets.
+    manager_.SetAlarm(clock_.ApproximateNow(), kShouldKeepAlive,
+                      kHasInflightPackets);
+  }
+
+  // Verify alarm is in keep-alive mode.
+  EXPECT_TRUE(alarm_->IsSet());
+  EXPECT_EQ(QuicTime::Delta::FromSeconds(kPingTimeoutSecs),
+            alarm_->deadline() - clock_.ApproximateNow());
+
+  clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
+  // Reset alarm with no in flight packets
+  manager_.SetAlarm(clock_.ApproximateNow(), kShouldKeepAlive,
+                    !kHasInflightPackets);
+  EXPECT_TRUE(alarm_->IsSet());
+  // Verify alarm is in keep-alive mode because retransmittable-on-wire deadline
+  // is later.
+  EXPECT_EQ(QuicTime::Delta::FromSeconds(kPingTimeoutSecs) -
+                QuicTime::Delta::FromMilliseconds(5),
+            alarm_->deadline() - clock_.ApproximateNow());
+  clock_.AdvanceTime(QuicTime::Delta::FromSeconds(kPingTimeoutSecs) -
+                     QuicTime::Delta::FromMilliseconds(5));
+  EXPECT_CALL(delegate_, OnKeepAliveTimeout());
+  alarm_->Fire();
+  EXPECT_FALSE(alarm_->IsSet());
+}
+
+TEST_F(QuicPingManagerTest,
+       ResetRetransmitableOnWireTimeoutExponentiallyBackOff) {
+  const int kMaxAggressiveRetransmittableOnWireCount = 3;
+  SetQuicFlag(FLAGS_quic_max_aggressive_retransmittable_on_wire_ping_count,
+              kMaxAggressiveRetransmittableOnWireCount);
+  const QuicTime::Delta initial_retransmittable_on_wire_timeout =
+      QuicTime::Delta::FromMilliseconds(200);
+  manager_.set_initial_retransmittable_on_wire_timeout(
+      initial_retransmittable_on_wire_timeout);
+
+  clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
+  EXPECT_FALSE(alarm_->IsSet());
+  manager_.SetAlarm(clock_.ApproximateNow(), kShouldKeepAlive,
+                    kHasInflightPackets);
+  // Verify alarm is in keep-alive mode.
+  EXPECT_TRUE(alarm_->IsSet());
+  EXPECT_EQ(QuicTime::Delta::FromSeconds(kPingTimeoutSecs),
+            alarm_->deadline() - clock_.ApproximateNow());
+
+  clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
+  manager_.SetAlarm(clock_.ApproximateNow(), kShouldKeepAlive,
+                    !kHasInflightPackets);
+  EXPECT_TRUE(alarm_->IsSet());
+  // Verify alarm is in retransmittable-on-wire mode.
+  EXPECT_EQ(initial_retransmittable_on_wire_timeout,
+            alarm_->deadline() - clock_.ApproximateNow());
+
+  EXPECT_CALL(delegate_, OnRetransmittableOnWireTimeout());
+  clock_.AdvanceTime(initial_retransmittable_on_wire_timeout);
+  alarm_->Fire();
+
+  clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
+  manager_.SetAlarm(clock_.ApproximateNow(), kShouldKeepAlive,
+                    !kHasInflightPackets);
+  EXPECT_TRUE(alarm_->IsSet());
+  EXPECT_EQ(initial_retransmittable_on_wire_timeout,
+            alarm_->deadline() - clock_.ApproximateNow());
+
+  manager_.reset_consecutive_retransmittable_on_wire_count();
+  manager_.SetAlarm(clock_.ApproximateNow(), kShouldKeepAlive,
+                    !kHasInflightPackets);
+  EXPECT_EQ(initial_retransmittable_on_wire_timeout,
+            alarm_->deadline() - clock_.ApproximateNow());
+
+  for (int i = 0; i < kMaxAggressiveRetransmittableOnWireCount; i++) {
+    manager_.SetAlarm(clock_.ApproximateNow(), kShouldKeepAlive,
+                      !kHasInflightPackets);
+    EXPECT_TRUE(alarm_->IsSet());
+    EXPECT_EQ(initial_retransmittable_on_wire_timeout,
+              alarm_->deadline() - clock_.ApproximateNow());
+    clock_.AdvanceTime(initial_retransmittable_on_wire_timeout);
+    EXPECT_CALL(delegate_, OnRetransmittableOnWireTimeout());
+    alarm_->Fire();
+    // Reset alarm with in flight packets.
+    manager_.SetAlarm(clock_.ApproximateNow(), kShouldKeepAlive,
+                      kHasInflightPackets);
+    // Advance 5ms to receive next packet.
+    clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
+  }
+
+  manager_.SetAlarm(clock_.ApproximateNow(), kShouldKeepAlive,
+                    !kHasInflightPackets);
+  EXPECT_TRUE(alarm_->IsSet());
+  EXPECT_EQ(initial_retransmittable_on_wire_timeout * 2,
+            alarm_->deadline() - clock_.ApproximateNow());
+
+  clock_.AdvanceTime(2 * initial_retransmittable_on_wire_timeout);
+  EXPECT_CALL(delegate_, OnRetransmittableOnWireTimeout());
+  alarm_->Fire();
+
+  clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
+  manager_.reset_consecutive_retransmittable_on_wire_count();
+  manager_.SetAlarm(clock_.ApproximateNow(), kShouldKeepAlive,
+                    !kHasInflightPackets);
+  EXPECT_TRUE(alarm_->IsSet());
+  EXPECT_EQ(initial_retransmittable_on_wire_timeout,
+            alarm_->deadline() - clock_.ApproximateNow());
+}
+
+TEST_F(QuicPingManagerTest, RetransmittableOnWireLimit) {
+  static constexpr int kMaxRetransmittableOnWirePingCount = 3;
+  SetQuicFlag(FLAGS_quic_max_retransmittable_on_wire_ping_count,
+              kMaxRetransmittableOnWirePingCount);
+  static constexpr QuicTime::Delta initial_retransmittable_on_wire_timeout =
+      QuicTime::Delta::FromMilliseconds(200);
+  static constexpr QuicTime::Delta kShortDelay =
+      QuicTime::Delta::FromMilliseconds(5);
+  ASSERT_LT(kShortDelay * 10, initial_retransmittable_on_wire_timeout);
+  manager_.set_initial_retransmittable_on_wire_timeout(
+      initial_retransmittable_on_wire_timeout);
+
+  clock_.AdvanceTime(kShortDelay);
+  EXPECT_FALSE(alarm_->IsSet());
+  manager_.SetAlarm(clock_.ApproximateNow(), kShouldKeepAlive,
+                    kHasInflightPackets);
+
+  EXPECT_TRUE(alarm_->IsSet());
+  EXPECT_EQ(QuicTime::Delta::FromSeconds(kPingTimeoutSecs),
+            alarm_->deadline() - clock_.ApproximateNow());
+
+  for (int i = 0; i <= kMaxRetransmittableOnWirePingCount; i++) {
+    clock_.AdvanceTime(kShortDelay);
+    manager_.SetAlarm(clock_.ApproximateNow(), kShouldKeepAlive,
+                      !kHasInflightPackets);
+    EXPECT_TRUE(alarm_->IsSet());
+    EXPECT_EQ(initial_retransmittable_on_wire_timeout,
+              alarm_->deadline() - clock_.ApproximateNow());
+    clock_.AdvanceTime(initial_retransmittable_on_wire_timeout);
+    EXPECT_CALL(delegate_, OnRetransmittableOnWireTimeout());
+    alarm_->Fire();
+    manager_.SetAlarm(clock_.ApproximateNow(), kShouldKeepAlive,
+                      kHasInflightPackets);
+  }
+
+  manager_.SetAlarm(clock_.ApproximateNow(), kShouldKeepAlive,
+                    !kHasInflightPackets);
+  EXPECT_TRUE(alarm_->IsSet());
+  // Verify alarm is in keep-alive mode.
+  EXPECT_EQ(QuicTime::Delta::FromSeconds(kPingTimeoutSecs),
+            alarm_->deadline() - clock_.ApproximateNow());
+  clock_.AdvanceTime(QuicTime::Delta::FromSeconds(kPingTimeoutSecs));
+  EXPECT_CALL(delegate_, OnKeepAliveTimeout());
+  alarm_->Fire();
+  EXPECT_FALSE(alarm_->IsSet());
+}
+
+}  // namespace
+
+}  // namespace test
+}  // namespace quic
diff --git a/quiche/quic/test_tools/quic_connection_peer.cc b/quiche/quic/test_tools/quic_connection_peer.cc
index e124580..9eaa6fb 100644
--- a/quiche/quic/test_tools/quic_connection_peer.cc
+++ b/quiche/quic/test_tools/quic_connection_peer.cc
@@ -64,6 +64,7 @@
                                         Perspective perspective) {
   connection->perspective_ = perspective;
   QuicFramerPeer::SetPerspective(&connection->framer_, perspective);
+  connection->ping_manager_.perspective_ = perspective;
 }
 
 // static
@@ -128,6 +129,9 @@
 
 // static
 QuicAlarm* QuicConnectionPeer::GetPingAlarm(QuicConnection* connection) {
+  if (GetQuicReloadableFlag(quic_use_ping_manager)) {
+    return connection->ping_manager_.alarm_.get();
+  }
   return connection->ping_alarm_.get();
 }