diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index 88810eb..c3c3fb2 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -367,8 +367,7 @@
                              &arena_,
                              alarm_factory_),
       encrypted_control_frames_(
-          GetQuicReloadableFlag(quic_encrypted_control_frames) &&
-          packet_creator_.let_connection_handle_pings()),
+          GetQuicReloadableFlag(quic_encrypted_control_frames)),
       use_encryption_level_context_(
           encrypted_control_frames_ &&
           GetQuicReloadableFlag(quic_use_encryption_level_context)),
@@ -3481,13 +3480,9 @@
       !visitor_->ShouldKeepConnectionAlive()) {
     return;
   }
-  if (packet_creator_.let_connection_handle_pings()) {
-    SendPingAtLevel(use_encryption_level_context_
-                        ? framer().GetEncryptionLevelToSendApplicationData()
-                        : encryption_level_);
-  } else {
-    visitor_->SendPing();
-  }
+  SendPingAtLevel(use_encryption_level_context_
+                      ? framer().GetEncryptionLevelToSendApplicationData()
+                      : encryption_level_);
 }
 
 void QuicConnection::SendAck() {
@@ -3583,19 +3578,15 @@
                     << "No packet gets sent when timer fires in mode "
                     << retransmission_mode << ", send PING";
     DCHECK_LT(0u, sent_packet_manager_.pending_timer_transmission_count());
-    if (packet_creator_.let_connection_handle_pings()) {
-      EncryptionLevel level = encryption_level_;
-      PacketNumberSpace packet_number_space = NUM_PACKET_NUMBER_SPACES;
-      if (SupportsMultiplePacketNumberSpaces() &&
-          sent_packet_manager_
-              .GetEarliestPacketSentTimeForPto(&packet_number_space)
-              .IsInitialized()) {
-        level = QuicUtils::GetEncryptionLevel(packet_number_space);
-      }
-      SendPingAtLevel(level);
-    } else {
-      visitor_->SendPing();
+    EncryptionLevel level = encryption_level_;
+    PacketNumberSpace packet_number_space = NUM_PACKET_NUMBER_SPACES;
+    if (SupportsMultiplePacketNumberSpaces() &&
+        sent_packet_manager_
+            .GetEarliestPacketSentTimeForPto(&packet_number_space)
+            .IsInitialized()) {
+      level = QuicUtils::GetEncryptionLevel(packet_number_space);
     }
+    SendPingAtLevel(level);
   }
   if (retransmission_mode == QuicSentPacketManager::PTO_MODE) {
     sent_packet_manager_.AdjustPendingTimerTransmissions();
@@ -5449,7 +5440,6 @@
 }
 
 void QuicConnection::SendPingAtLevel(EncryptionLevel level) {
-  DCHECK(packet_creator_.let_connection_handle_pings());
   ScopedEncryptionLevelContext context(this, level);
   SendControlFrame(QuicFrame(QuicPingFrame()));
 }
diff --git a/quic/core/quic_connection.h b/quic/core/quic_connection.h
index 13a3518..8dd0b0b 100644
--- a/quic/core/quic_connection.h
+++ b/quic/core/quic_connection.h
@@ -161,9 +161,6 @@
   // retransmittable frame needs to be added.
   virtual void OnAckNeedsRetransmittableFrame() = 0;
 
-  // Called when a ping needs to be sent.
-  virtual void SendPing() = 0;
-
   // Called when an AckFrequency frame need to be sent.
   virtual void SendAckFrequency(const QuicAckFrequencyFrame& frame) = 0;
 
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index bf3fe0a..941bd21 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -3960,11 +3960,6 @@
             connection_.GetPingAlarm()->deadline() - clock_.ApproximateNow());
 
   // Simulate firing of the retransmittable on wire and send a PING.
-  if (!GetQuicReloadableFlag(quic_let_connection_handle_pings)) {
-    EXPECT_CALL(visitor_, SendPing()).WillOnce(Invoke([this]() {
-      SendPing();
-    }));
-  }
   clock_.AdvanceTime(retransmittable_on_wire_timeout);
   connection_.GetPingAlarm()->Fire();
 
@@ -3978,21 +3973,14 @@
       QuicTime::Delta::FromMilliseconds(kMinRetransmissionTimeMs);
   srtt = manager_->GetRttStats()->SmoothedOrInitialRtt();
 
-  if (GetQuicReloadableFlag(quic_let_connection_handle_pings)) {
-    // Arm RTO mode since there is only PING in flight.
-    expected_delay = manager_->GetPtoDelay();
-  } else {
-    // First TLP without unacked stream data will no longer use TLPR.
-    expected_delay = std::max(2 * srtt, 1.5 * srtt + 0.5 * min_rto_timeout);
-  }
+  // Arm RTO mode since there is only PING in flight.
+  expected_delay = manager_->GetPtoDelay();
   EXPECT_EQ(expected_delay,
             connection_.GetRetransmissionAlarm()->deadline() - clock_.Now());
 
   // Verify the path degrading delay = TLP delay + 1st RTO + 2nd RTO.
   // Add 1st RTO.
-  if (GetQuicReloadableFlag(quic_let_connection_handle_pings)) {
-    expected_delay = std::max(2 * srtt, 1.5 * srtt + 0.5 * min_rto_timeout);
-  }
+  expected_delay = std::max(2 * srtt, 1.5 * srtt + 0.5 * min_rto_timeout);
   retransmission_delay =
       std::max(manager_->GetRttStats()->smoothed_rtt() +
                    4 * manager_->GetRttStats()->mean_deviation(),
@@ -4019,12 +4007,8 @@
 
   // Verify the retransmission delay.
   // First TLP without unacked stream data will no longer use TLPR.
-  if (GetQuicReloadableFlag(quic_let_connection_handle_pings)) {
-    // Arm RTO mode since there is only PING in flight.
-    expected_delay = manager_->GetPtoDelay();
-  } else {
-    expected_delay = std::max(2 * srtt, 1.5 * srtt + 0.5 * min_rto_timeout);
-  }
+  // Arm RTO mode since there is only PING in flight.
+  expected_delay = manager_->GetPtoDelay();
   expected_delay = expected_delay - QuicTime::Delta::FromMilliseconds(5);
   EXPECT_EQ(expected_delay,
             connection_.GetRetransmissionAlarm()->deadline() - clock_.Now());
@@ -4550,11 +4534,6 @@
 
   writer_->Reset();
   clock_.AdvanceTime(QuicTime::Delta::FromSeconds(15));
-  if (!GetQuicReloadableFlag(quic_let_connection_handle_pings)) {
-    EXPECT_CALL(visitor_, SendPing()).WillOnce(Invoke([this]() {
-      SendPing();
-    }));
-  }
   connection_.GetPingAlarm()->Fire();
   size_t padding_frame_count = writer_->padding_frames().size();
   EXPECT_EQ(padding_frame_count + 1u, writer_->frame_count());
@@ -4608,11 +4587,6 @@
 
   writer_->Reset();
   clock_.AdvanceTime(QuicTime::Delta::FromSeconds(10));
-  if (!GetQuicReloadableFlag(quic_let_connection_handle_pings)) {
-    EXPECT_CALL(visitor_, SendPing()).WillOnce(Invoke([this]() {
-      connection_.SendControlFrame(QuicFrame(QuicPingFrame(1)));
-    }));
-  }
   connection_.GetPingAlarm()->Fire();
   size_t padding_frame_count = writer_->padding_frames().size();
   EXPECT_EQ(padding_frame_count + 1u, writer_->frame_count());
@@ -7103,11 +7077,6 @@
 
   // Simulate firing the ping alarm and sending a PING.
   clock_.AdvanceTime(retransmittable_on_wire_timeout);
-  if (!GetQuicReloadableFlag(quic_let_connection_handle_pings)) {
-    EXPECT_CALL(visitor_, SendPing()).WillOnce(Invoke([this]() {
-      connection_.SendControlFrame(QuicFrame(QuicPingFrame(1)));
-    }));
-  }
   connection_.GetPingAlarm()->Fire();
 
   // Now there's a retransmittable packet (PING) on the wire, so the path
@@ -7829,11 +7798,6 @@
   EXPECT_EQ(prev_deadline, connection_.GetPingAlarm()->deadline());
 
   // Simulate the alarm firing and check that a PING is sent.
-  if (!GetQuicReloadableFlag(quic_let_connection_handle_pings)) {
-    EXPECT_CALL(visitor_, SendPing()).WillOnce(Invoke([this]() {
-      connection_.SendControlFrame(QuicFrame(QuicPingFrame(1)));
-    }));
-  }
   connection_.GetPingAlarm()->Fire();
   size_t padding_frame_count = writer_->padding_frames().size();
   if (GetParam().no_stop_waiting) {
@@ -7904,11 +7868,6 @@
 
   // Simulate the alarm firing and check that a PING is sent.
   writer_->Reset();
-  if (!GetQuicReloadableFlag(quic_let_connection_handle_pings)) {
-    EXPECT_CALL(visitor_, SendPing()).WillOnce(Invoke([this]() {
-      connection_.SendControlFrame(QuicFrame(QuicPingFrame(1)));
-    }));
-  }
   connection_.GetPingAlarm()->Fire();
   size_t padding_frame_count = writer_->padding_frames().size();
   if (GetParam().no_stop_waiting) {
@@ -7968,11 +7927,6 @@
               connection_.GetPingAlarm()->deadline() - clock_.ApproximateNow());
     // Simulate the alarm firing and check that a PING is sent.
     writer_->Reset();
-    if (!GetQuicReloadableFlag(quic_let_connection_handle_pings)) {
-      EXPECT_CALL(visitor_, SendPing()).WillOnce(Invoke([this]() {
-        SendPing();
-      }));
-    }
     clock_.AdvanceTime(initial_retransmittable_on_wire_timeout);
     connection_.GetPingAlarm()->Fire();
   }
@@ -7997,11 +7951,6 @@
 
     // Simulate the alarm firing and check that a PING is sent.
     writer_->Reset();
-    if (!GetQuicReloadableFlag(quic_let_connection_handle_pings)) {
-      EXPECT_CALL(visitor_, SendPing()).WillOnce(Invoke([this]() {
-        SendPing();
-      }));
-    }
     clock_.AdvanceTime(retransmittable_on_wire_timeout);
     connection_.GetPingAlarm()->Fire();
   }
@@ -8067,11 +8016,6 @@
 
   // Simulate the alarm firing and check that a PING is sent.
   writer_->Reset();
-  if (!GetQuicReloadableFlag(quic_let_connection_handle_pings)) {
-    EXPECT_CALL(visitor_, SendPing()).WillOnce(Invoke([this]() {
-      SendPing();
-    }));
-  }
   clock_.AdvanceTime(initial_retransmittable_on_wire_timeout);
   connection_.GetPingAlarm()->Fire();
 
@@ -8107,11 +8051,6 @@
               connection_.GetPingAlarm()->deadline() - clock_.ApproximateNow());
     // Simulate the alarm firing and check that a PING is sent.
     writer_->Reset();
-    if (!GetQuicReloadableFlag(quic_let_connection_handle_pings)) {
-      EXPECT_CALL(visitor_, SendPing()).WillOnce(Invoke([this]() {
-        SendPing();
-      }));
-    }
     clock_.AdvanceTime(initial_retransmittable_on_wire_timeout);
     connection_.GetPingAlarm()->Fire();
     // Advance 5ms to receive next packet.
@@ -8129,11 +8068,6 @@
             connection_.GetPingAlarm()->deadline() - clock_.ApproximateNow());
 
   writer_->Reset();
-  if (!GetQuicReloadableFlag(quic_let_connection_handle_pings)) {
-    EXPECT_CALL(visitor_, SendPing()).WillOnce(Invoke([this]() {
-      SendPing();
-    }));
-  }
   clock_.AdvanceTime(2 * initial_retransmittable_on_wire_timeout);
   connection_.GetPingAlarm()->Fire();
 
@@ -8202,11 +8136,6 @@
               connection_.GetPingAlarm()->deadline() - clock_.ApproximateNow());
     // Simulate the alarm firing and check that a PING is sent.
     writer_->Reset();
-    if (!GetQuicReloadableFlag(quic_let_connection_handle_pings)) {
-      EXPECT_CALL(visitor_, SendPing()).WillOnce(Invoke([this]() {
-        SendPing();
-      }));
-    }
     clock_.AdvanceTime(initial_retransmittable_on_wire_timeout);
     connection_.GetPingAlarm()->Fire();
   }
@@ -9141,11 +9070,6 @@
 
   // RTO fires, verify a PING packet gets sent because there is no data to send.
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, QuicPacketNumber(3), _, _));
-  if (!GetQuicReloadableFlag(quic_let_connection_handle_pings)) {
-    EXPECT_CALL(visitor_, SendPing()).WillOnce(Invoke([this]() {
-      SendPing();
-    }));
-  }
   clock_.AdvanceTime(retransmission_time - clock_.Now());
   connection_.GetRetransmissionAlarm()->Fire();
   EXPECT_EQ(1u, connection_.GetStats().tlp_count);
@@ -9365,11 +9289,6 @@
                                ? QuicPacketNumber(2)
                                : QuicPacketNumber(3),
                            _, _));
-  if (!GetQuicReloadableFlag(quic_let_connection_handle_pings)) {
-    EXPECT_CALL(visitor_, SendPing()).WillOnce(Invoke([this]() {
-      SendPing();
-    }));
-  }
   connection_.GetRetransmissionAlarm()->Fire();
   EXPECT_EQ(1u, connection_.GetStats().pto_count);
   EXPECT_EQ(1u, connection_.GetStats().crypto_retransmit_count);
@@ -9666,11 +9585,6 @@
   // Fires TLP, verify a PING gets sent because packet 3 is marked
   // RTO_RETRANSMITTED.
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, QuicPacketNumber(70), _, _));
-  if (!GetQuicReloadableFlag(quic_let_connection_handle_pings)) {
-    EXPECT_CALL(visitor_, SendPing()).WillOnce(Invoke([this]() {
-      SendPing();
-    }));
-  }
   connection_.GetRetransmissionAlarm()->Fire();
 }
 
@@ -10240,11 +10154,6 @@
   // PTO fires, verify a PING packet gets sent because there is no data to
   // send.
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, QuicPacketNumber(3), _, _));
-  if (!GetQuicReloadableFlag(quic_let_connection_handle_pings)) {
-    EXPECT_CALL(visitor_, SendPing()).WillOnce(Invoke([this]() {
-      SendPing();
-    }));
-  }
   connection_.GetRetransmissionAlarm()->Fire();
   EXPECT_EQ(1u, connection_.GetStats().pto_count);
   EXPECT_EQ(0u, connection_.GetStats().crypto_retransmit_count);
@@ -11008,11 +10917,7 @@
   EXPECT_CALL(visitor_, ShouldKeepConnectionAlive())
       .WillRepeatedly(Return(false));
   // Verify PING does not get sent.
-  if (GetQuicReloadableFlag(quic_let_connection_handle_pings)) {
-    EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0);
-  } else {
-    EXPECT_CALL(visitor_, SendPing()).Times(0);
-  }
+  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0);
   connection_.GetPingAlarm()->Fire();
 }
 
@@ -11865,11 +11770,6 @@
   EXPECT_TRUE(connection_.GetRetransmissionAlarm()->IsSet());
 
   // Fire retransmission alarm.
-  if (!GetQuicReloadableFlag(quic_let_connection_handle_pings)) {
-    EXPECT_CALL(visitor_, SendPing()).WillOnce(Invoke([this]() {
-      SendPing();
-    }));
-  }
   connection_.GetRetransmissionAlarm()->Fire();
 
   QuicFrames frames1;
diff --git a/quic/core/quic_control_frame_manager.cc b/quic/core/quic_control_frame_manager.cc
index 6a64cb6..3940b9c 100644
--- a/quic/core/quic_control_frame_manager.cc
+++ b/quic/core/quic_control_frame_manager.cc
@@ -137,27 +137,6 @@
       QuicFrame(new QuicNewTokenFrame(++last_control_frame_id_, token)));
 }
 
-void QuicControlFrameManager::WritePing() {
-  QUIC_DVLOG(1) << "Writing PING_FRAME";
-  if (HasBufferedFrames()) {
-    // Do not send ping if there is buffered frames.
-    QUIC_LOG(WARNING)
-        << "Try to send PING when there is buffered control frames.";
-    return;
-  }
-  control_frames_.emplace_back(
-      QuicFrame(QuicPingFrame(++last_control_frame_id_)));
-  if (control_frames_.size() > kMaxNumControlFrames) {
-    delegate_->OnControlFrameManagerError(
-        QUIC_TOO_MANY_BUFFERED_CONTROL_FRAMES,
-        absl::StrCat("More than ", kMaxNumControlFrames,
-                     "buffered control frames, least_unacked: ", least_unacked_,
-                     ", least_unsent_: ", least_unsent_));
-    return;
-  }
-  WriteBufferedFrames();
-}
-
 void QuicControlFrameManager::OnControlFrameSent(const QuicFrame& frame) {
   QuicControlFrameId id = GetControlFrameId(frame);
   if (id == kInvalidControlFrameId) {
diff --git a/quic/core/quic_control_frame_manager.h b/quic/core/quic_control_frame_manager.h
index f5bc0b6..1cc0c57 100644
--- a/quic/core/quic_control_frame_manager.h
+++ b/quic/core/quic_control_frame_manager.h
@@ -93,9 +93,6 @@
   // immediately.
   void WriteOrBufferNewToken(absl::string_view token);
 
-  // Sends a PING_FRAME. Do not send PING if there is buffered frames.
-  void WritePing();
-
   // Called when |frame| gets acked. Returns true if |frame| gets acked for the
   // first time, return false otherwise.
   bool OnControlFrameAcked(const QuicFrame& frame);
diff --git a/quic/core/quic_control_frame_manager_test.cc b/quic/core/quic_control_frame_manager_test.cc
index 68658bb..bad8a665 100644
--- a/quic/core/quic_control_frame_manager_test.cc
+++ b/quic/core/quic_control_frame_manager_test.cc
@@ -72,7 +72,6 @@
     manager_->WriteOrBufferBlocked(kTestStreamId);
     manager_->WriteOrBufferStopSending(kTestStopSendingCode, kTestStreamId);
     number_of_frames_ = 5u;
-    ping_frame_id_ = 6u;
     EXPECT_EQ(number_of_frames_,
               QuicControlFrameManagerPeer::QueueSize(manager_.get()));
     EXPECT_TRUE(manager_->IsControlFrameOutstanding(QuicFrame(&rst_stream_)));
@@ -81,8 +80,6 @@
         manager_->IsControlFrameOutstanding(QuicFrame(&window_update_)));
     EXPECT_TRUE(manager_->IsControlFrameOutstanding(QuicFrame(&blocked_)));
     EXPECT_TRUE(manager_->IsControlFrameOutstanding(QuicFrame(&stop_sending_)));
-    EXPECT_FALSE(manager_->IsControlFrameOutstanding(
-        QuicFrame(QuicPingFrame(ping_frame_id_))));
 
     EXPECT_FALSE(manager_->HasPendingRetransmission());
     EXPECT_TRUE(manager_->WillingToWrite());
@@ -101,7 +98,6 @@
   std::unique_ptr<QuicControlFrameManager> manager_;
   QuicFrame frame_;
   size_t number_of_frames_;
-  int ping_frame_id_;
 };
 
 TEST_F(QuicControlFrameManagerTest, OnControlFrameAcked) {
@@ -119,8 +115,6 @@
   EXPECT_TRUE(manager_->IsControlFrameOutstanding(QuicFrame(&blocked_)));
   EXPECT_TRUE(manager_->IsControlFrameOutstanding(QuicFrame(&stop_sending_)));
 
-  EXPECT_FALSE(manager_->IsControlFrameOutstanding(
-      QuicFrame(QuicPingFrame(ping_frame_id_))));
   EXPECT_TRUE(manager_->OnControlFrameAcked(QuicFrame(&window_update_)));
   EXPECT_FALSE(manager_->IsControlFrameOutstanding(QuicFrame(&window_update_)));
   EXPECT_EQ(number_of_frames_,
@@ -146,7 +140,6 @@
   EXPECT_CALL(*session_, WriteControlFrame(_, _))
       .WillRepeatedly(Invoke(&ClearControlFrameWithTransmissionType));
   manager_->OnCanWrite();
-  manager_->WritePing();
   EXPECT_FALSE(manager_->WillingToWrite());
 }
 
@@ -179,10 +172,9 @@
 
   // Send control frames 4, 5, and 6.
   EXPECT_CALL(*session_, WriteControlFrame(_, _))
-      .Times(number_of_frames_ - 2u)
+      .Times(number_of_frames_ - 3u)
       .WillRepeatedly(Invoke(&ClearControlFrameWithTransmissionType));
   manager_->OnCanWrite();
-  manager_->WritePing();
   EXPECT_FALSE(manager_->WillingToWrite());
 }
 
@@ -214,28 +206,6 @@
                                                 PTO_RETRANSMISSION));
 }
 
-TEST_F(QuicControlFrameManagerTest, DonotSendPingWithBufferedFrames) {
-  Initialize();
-  InSequence s;
-  EXPECT_CALL(*session_, WriteControlFrame(_, _))
-      .WillOnce(Invoke(&ClearControlFrameWithTransmissionType));
-  EXPECT_CALL(*session_, WriteControlFrame(_, _)).WillOnce(Return(false));
-  // Send control frame 1.
-  manager_->OnCanWrite();
-  EXPECT_FALSE(manager_->HasPendingRetransmission());
-  EXPECT_TRUE(manager_->WillingToWrite());
-
-  // Send PING when there is buffered frames.
-  manager_->WritePing();
-  // Verify only the buffered frames are sent.
-  EXPECT_CALL(*session_, WriteControlFrame(_, _))
-      .Times(number_of_frames_ - 1)
-      .WillRepeatedly(Invoke(&ClearControlFrameWithTransmissionType));
-  manager_->OnCanWrite();
-  EXPECT_FALSE(manager_->HasPendingRetransmission());
-  EXPECT_FALSE(manager_->WillingToWrite());
-}
-
 TEST_F(QuicControlFrameManagerTest, SendAndAckAckFrequencyFrame) {
   Initialize();
   InSequence s;
diff --git a/quic/core/quic_flags_list.h b/quic/core/quic_flags_list.h
index f3a9a4b..908aa12 100644
--- a/quic/core/quic_flags_list.h
+++ b/quic/core/quic_flags_list.h
@@ -40,7 +40,6 @@
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_fix_willing_and_able_to_write2, true)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_goaway_with_max_stream_id, false)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_granular_qpack_error_codes, true)
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_let_connection_handle_pings, true)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_new_priority_update_frame, true)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_pass_path_response_to_validator, false)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_require_handshake_confirmation, false)
diff --git a/quic/core/quic_packet_creator.cc b/quic/core/quic_packet_creator.cc
index 08ac9c7..858a403 100644
--- a/quic/core/quic_packet_creator.cc
+++ b/quic/core/quic_packet_creator.cc
@@ -134,9 +134,6 @@
       fully_pad_crypto_handshake_packets_(true),
       latched_hard_max_packet_length_(0),
       max_datagram_frame_size_(0) {
-  if (let_connection_handle_pings_) {
-    QUIC_RELOADABLE_FLAG_COUNT(quic_let_connection_handle_pings);
-  }
   SetMaxPacketLength(kDefaultMaxPacketSize);
   if (!framer_->version().UsesTls()) {
     // QUIC+TLS negotiates the maximum datagram frame size via the
@@ -1191,7 +1188,7 @@
 bool QuicPacketCreator::ConsumeRetransmittableControlFrame(
     const QuicFrame& frame) {
   QUIC_BUG_IF(IsControlFrame(frame.type) && !GetControlFrameId(frame) &&
-              (!let_connection_handle_pings_ || frame.type != PING_FRAME))
+              frame.type != PING_FRAME)
       << "Adding a control frame with no control frame id: " << frame;
   DCHECK(QuicUtils::IsRetransmittableFrame(frame.type)) << frame;
   MaybeBundleAckOpportunistically();
diff --git a/quic/core/quic_packet_creator.h b/quic/core/quic_packet_creator.h
index 2605740..842837c 100644
--- a/quic/core/quic_packet_creator.h
+++ b/quic/core/quic_packet_creator.h
@@ -471,10 +471,6 @@
   // Return true if retry_token_ is not empty.
   bool HasRetryToken() const;
 
-  bool let_connection_handle_pings() const {
-    return let_connection_handle_pings_;
-  }
-
  private:
   friend class test::QuicPacketCreatorPeer;
 
@@ -673,9 +669,6 @@
   // accept. There is no limit for QUIC_CRYPTO connections, but QUIC+TLS
   // negotiates this during the handshake.
   QuicByteCount max_datagram_frame_size_;
-
-  const bool let_connection_handle_pings_ =
-      GetQuicReloadableFlag(quic_let_connection_handle_pings);
 };
 
 }  // namespace quic
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index b0fdb3c..73370d3 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -2091,10 +2091,6 @@
   flow_controller_.SendWindowUpdate();
 }
 
-void QuicSession::SendPing() {
-  control_frame_manager_.WritePing();
-}
-
 void QuicSession::SendAckFrequency(const QuicAckFrequencyFrame& frame) {
   control_frame_manager_.WriteOrBufferAckFrequency(frame);
 }
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index 8e572d3..d849743 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -134,7 +134,6 @@
   void OnConnectionMigration(AddressChangeType /*type*/) override {}
   // Adds a connection level WINDOW_UPDATE frame.
   void OnAckNeedsRetransmittableFrame() override;
-  void SendPing() override;
   void SendAckFrequency(const QuicAckFrequencyFrame& frame) override;
   bool WillingAndAbleToWrite() const override;
   std::string GetStreamsInfoForLogging() const override;
diff --git a/quic/test_tools/quic_test_utils.h b/quic/test_tools/quic_test_utils.h
index 825b669..6fbcc17 100644
--- a/quic/test_tools/quic_test_utils.h
+++ b/quic/test_tools/quic_test_utils.h
@@ -567,7 +567,6 @@
                bool is_connectivity_probe),
               (override));
   MOCK_METHOD(void, OnAckNeedsRetransmittableFrame, (), (override));
-  MOCK_METHOD(void, SendPing, (), (override));
   MOCK_METHOD(void,
               SendAckFrequency,
               (const QuicAckFrequencyFrame& frame),
diff --git a/quic/test_tools/simulator/quic_endpoint.h b/quic/test_tools/simulator/quic_endpoint.h
index 4485025..fd2fa06 100644
--- a/quic/test_tools/simulator/quic_endpoint.h
+++ b/quic/test_tools/simulator/quic_endpoint.h
@@ -80,7 +80,6 @@
   void OnPathDegrading() override {}
   void OnForwardProgressMadeAfterPathDegrading() override {}
   void OnAckNeedsRetransmittableFrame() override {}
-  void SendPing() override {}
   void SendAckFrequency(const QuicAckFrequencyFrame& /*frame*/) override {}
   bool AllowSelfAddressChange() const override;
   HandshakeState GetHandshakeState() const override;