diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index 10e867c..9342bd6 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -370,7 +370,8 @@
       use_encryption_level_context_(
           encrypted_control_frames_ &&
           GetQuicReloadableFlag(quic_use_encryption_level_context)),
-      path_validator_(alarm_factory_, &arena_, this, random_generator_) {
+      path_validator_(alarm_factory_, &arena_, this, random_generator_),
+      most_recent_alternative_path_(QuicSocketAddress(), QuicSocketAddress()) {
   QUIC_BUG_IF(!start_peer_migration_earlier_ && send_path_response_);
 
   DCHECK(perspective_ == Perspective::IS_CLIENT ||
@@ -2348,6 +2349,7 @@
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnPacketReceived(self_address, peer_address, packet);
   }
+  current_incoming_packet_received_bytes_counted_ = false;
   last_size_ = packet.length();
   current_packet_data_ = packet.data();
 
@@ -2375,7 +2377,15 @@
 
   stats_.bytes_received += packet.length();
   ++stats_.packets_received;
-  if (EnforceAntiAmplificationLimit()) {
+  if (!count_bytes_on_alternative_path_seperately_) {
+    if (EnforceAntiAmplificationLimit()) {
+      bytes_received_before_address_validation_ += last_size_;
+    }
+  } else if (IsDefaultPath(last_packet_destination_address_,
+                           last_packet_source_address_) &&
+             EnforceAntiAmplificationLimit()) {
+    QUIC_CODE_COUNT_N(quic_count_bytes_on_alternative_path_seperately, 1, 5);
+    current_incoming_packet_received_bytes_counted_ = true;
     bytes_received_before_address_validation_ += last_size_;
   }
 
@@ -2469,9 +2479,10 @@
   // evaluate if it's worth to send them before sending ACKs.
   while (!pending_path_challenge_payloads_.empty()) {
     QUIC_RELOADABLE_FLAG_COUNT_N(quic_send_path_response, 4, 5);
-    std::pair<QuicPathFrameBuffer, QuicSocketAddress> pair =
+    const PendingPathChallenge& pending_path_challenge =
         pending_path_challenge_payloads_.front();
-    if (!SendPathResponse(pair.first, pair.second)) {
+    if (!SendPathResponse(pending_path_challenge.received_path_challenge,
+                          pending_path_challenge.peer_address)) {
       break;
     }
     pending_path_challenge_payloads_.pop_front();
@@ -2683,7 +2694,18 @@
          QuicVersionUsesCryptoFrames(transport_version()))
       << ENDPOINT
       << "Handshake in STREAM frames should not check ShouldGeneratePacket";
-  return CanWrite(retransmittable);
+  if (!count_bytes_on_alternative_path_seperately_) {
+    return CanWrite(retransmittable);
+  }
+  QUIC_CODE_COUNT_N(quic_count_bytes_on_alternative_path_seperately, 4, 5);
+  if (IsDefaultPath(self_address_, packet_creator_.peer_address())) {
+    return CanWrite(retransmittable);
+  }
+  // This is checking on the alternative path with a different peer address. The
+  // self address and the writer used are the same as the default path. In the
+  // case of different self address and writer, writing packet would use a
+  // differnt code path without checking the states of the default writer.
+  return connected_ && !HandleWriteBlocked();
 }
 
 const QuicFrames QuicConnection::MaybeBundleAckOpportunistically() {
@@ -2739,7 +2761,9 @@
   if (LimitedByAmplificationFactor()) {
     // Server is constrained by the amplification restriction.
     QUIC_CODE_COUNT(quic_throttled_by_amplification_limit);
-    QUIC_DVLOG(1) << ENDPOINT << "Constrained by amplification restriction";
+    QUIC_DVLOG(1) << ENDPOINT
+                  << "Constrained by amplification restriction to peer address "
+                  << direct_peer_address_;
     ++stats_.num_amplification_throttling;
     return false;
   }
@@ -2753,7 +2777,7 @@
     return false;
   }
 
-  // Allow acks to be sent immediately.
+  // Allow acks and probing frames to be sent immediately.
   if (retransmittable == NO_RETRANSMITTABLE_DATA) {
     return true;
   }
@@ -2853,7 +2877,7 @@
                         : " ack or probing only ")
                 << ", encryption level: " << packet->encryption_level
                 << ", encrypted length:" << encrypted_length
-                << ", fate: " << fate;
+                << ", fate: " << fate << " to peer " << packet->peer_address;
   QUIC_DVLOG(2) << ENDPOINT << packet->encryption_level << " packet number "
                 << packet_number << " of length " << encrypted_length << ": "
                 << std::endl
@@ -3069,9 +3093,22 @@
   QUIC_DVLOG(1) << ENDPOINT << "time we began writing last sent packet: "
                 << packet_send_time.ToDebuggingValue();
 
-  if (EnforceAntiAmplificationLimit()) {
-    // Include bytes sent even if they are not in flight.
-    bytes_sent_before_address_validation_ += encrypted_length;
+  if (!count_bytes_on_alternative_path_seperately_) {
+    if (EnforceAntiAmplificationLimit()) {
+      // Include bytes sent even if they are not in flight.
+      bytes_sent_before_address_validation_ += encrypted_length;
+    }
+  } else {
+    QUIC_CODE_COUNT_N(quic_count_bytes_on_alternative_path_seperately, 2, 5);
+    if (IsDefaultPath(self_address_, send_to_address)) {
+      if (EnforceAntiAmplificationLimit()) {
+        // Include bytes sent even if they are not in flight.
+        bytes_sent_before_address_validation_ += encrypted_length;
+      }
+    } else {
+      MaybeUpdateBytesSentToAlternativeAddress(send_to_address,
+                                               encrypted_length);
+    }
   }
 
   // Do not measure rtt of this packet if it's not sent on current path.
@@ -4633,7 +4670,30 @@
 
 void QuicConnection::UpdatePacketContent(QuicFrameType type) {
   if (version().HasIetfQuicFrames()) {
-    MaybeStartIetfPeerMigration(type);
+    if (!QuicUtils::IsProbingFrame(type)) {
+      MaybeStartIetfPeerMigration();
+      return;
+    }
+    QuicSocketAddress current_effective_peer_address =
+        GetEffectivePeerAddressFromCurrentPacket();
+    if (!count_bytes_on_alternative_path_seperately_ ||
+        IsDefaultPath(last_packet_destination_address_,
+                      last_packet_source_address_)) {
+      return;
+    }
+    QUIC_CODE_COUNT_N(quic_count_bytes_on_alternative_path_seperately, 3, 5);
+    if (type == PATH_CHALLENGE_FRAME &&
+        !IsMostRecentAlternativePath(last_packet_destination_address_,
+                                     current_effective_peer_address)) {
+      // Only override most recent alternative path state upon a PATH_CHALLENGE.
+      QUIC_DVLOG(1)
+          << "The peer is probing a new path with effective peer address "
+          << current_effective_peer_address << ",  self address "
+          << last_packet_destination_address_;
+      most_recent_alternative_path_ = AlternativePathState(
+          last_packet_destination_address_, current_effective_peer_address);
+    }
+    MaybeUpdateBytesReceivedFromAlternativeAddress(last_size_);
     return;
   }
   // Packet content is tracked to identify connectivity probe in non-IETF
@@ -4697,9 +4757,9 @@
   current_effective_peer_migration_type_ = NO_CHANGE;
 }
 
-void QuicConnection::MaybeStartIetfPeerMigration(QuicFrameType type) {
+void QuicConnection::MaybeStartIetfPeerMigration() {
   DCHECK(version().HasIetfQuicFrames());
-  if (!start_peer_migration_earlier_ || QuicUtils::IsProbingFrame(type)) {
+  if (!start_peer_migration_earlier_) {
     return;
   }
   QUIC_CODE_COUNT(quic_start_peer_migration_earlier);
@@ -5083,8 +5143,22 @@
   // Account for added padding.
   if (length > coalesced_packet_.length()) {
     size_t padding_size = length - coalesced_packet_.length();
-    if (EnforceAntiAmplificationLimit()) {
-      bytes_sent_before_address_validation_ += padding_size;
+    if (!count_bytes_on_alternative_path_seperately_) {
+      if (EnforceAntiAmplificationLimit()) {
+        bytes_sent_before_address_validation_ += padding_size;
+      }
+    } else {
+      QUIC_CODE_COUNT_N(quic_count_bytes_on_alternative_path_seperately, 5, 5);
+      if (IsDefaultPath(coalesced_packet_.self_address(),
+                        coalesced_packet_.peer_address())) {
+        if (EnforceAntiAmplificationLimit()) {
+          // Include bytes sent even if they are not in flight.
+          bytes_sent_before_address_validation_ += padding_size;
+        }
+      } else {
+        MaybeUpdateBytesSentToAlternativeAddress(
+            coalesced_packet_.peer_address(), padding_size);
+      }
     }
     stats_.bytes_sent += padding_size;
     if (coalesced_packet_.initial_packet() != nullptr &&
@@ -5414,6 +5488,7 @@
       packet_creator_.SerializePathChallengeConnectivityProbingPacket(
           data_buffer);
   DCHECK_EQ(IsRetransmittable(*probing_packet), NO_RETRANSMITTABLE_DATA);
+  DCHECK_EQ(self_address, most_recent_alternative_path_.self_address);
   WritePacketUsingWriter(std::move(probing_packet), writer, self_address,
                          peer_address, /*measure_rtt=*/false);
   return true;
@@ -5432,6 +5507,11 @@
 void QuicConnection::ValidatePath(
     std::unique_ptr<QuicPathValidationContext> context,
     std::unique_ptr<QuicPathValidator::ResultDelegate> result_delegate) {
+  if (perspective_ == Perspective::IS_CLIENT &&
+      !IsDefaultPath(context->self_address(), context->peer_address())) {
+    most_recent_alternative_path_ =
+        AlternativePathState(context->self_address(), context->peer_address());
+  }
   path_validator_.StartPathValidation(std::move(context),
                                       std::move(result_delegate));
 }
@@ -5441,9 +5521,9 @@
   // Send PATH_RESPONSE using the provided peer address. If the creator has been
   // using a different peer address, it will flush before and after serializing
   // the current PATH_RESPONSE.
-  QUIC_DVLOG(1) << ENDPOINT << "Send PATH_RESPONSE to " << peer_address_to_send;
   QuicPacketCreator::ScopedPeerAddressContext context(&packet_creator_,
                                                       peer_address_to_send);
+  QUIC_DVLOG(1) << ENDPOINT << "Send PATH_RESPONSE to " << peer_address_to_send;
   return packet_creator_.AddPathResponseFrame(data_buffer);
 }
 
@@ -5496,5 +5576,74 @@
   }
 }
 
+void QuicConnection::MaybeUpdateBytesSentToAlternativeAddress(
+    const QuicSocketAddress& peer_address,
+    QuicByteCount sent_packet_size) {
+  if (!version().SupportsAntiAmplificationLimit() ||
+      perspective_ != Perspective::IS_SERVER) {
+    return;
+  }
+  DCHECK(!IsDefaultPath(self_address_, peer_address));
+  if (!IsMostRecentAlternativePath(self_address_, peer_address)) {
+    QUIC_DLOG(INFO) << "Wrote to uninteresting peer address: " << peer_address
+                    << " default direct_peer_address_ " << direct_peer_address_
+                    << " alternative path peer address "
+                    << most_recent_alternative_path_.peer_address;
+    return;
+  }
+  if (most_recent_alternative_path_.validated) {
+    return;
+  }
+  if (most_recent_alternative_path_.bytes_sent_before_address_validation_ >=
+      anti_amplification_factor_ *
+          most_recent_alternative_path_
+              .bytes_received_before_address_validation_) {
+    QUIC_LOG_FIRST_N(WARNING, 100)
+        << "Server sent more data than allowed to unverified alternative "
+           "peer address "
+        << peer_address << " bytes sent "
+        << most_recent_alternative_path_.bytes_sent_before_address_validation_
+        << ", bytes received "
+        << most_recent_alternative_path_
+               .bytes_received_before_address_validation_;
+  }
+  most_recent_alternative_path_.bytes_sent_before_address_validation_ +=
+      sent_packet_size;
+}
+
+void QuicConnection::MaybeUpdateBytesReceivedFromAlternativeAddress(
+    QuicByteCount received_packet_size) {
+  if (!version().SupportsAntiAmplificationLimit() ||
+      perspective_ != Perspective::IS_SERVER ||
+      !IsMostRecentAlternativePath(
+          last_packet_destination_address_,
+          GetEffectivePeerAddressFromCurrentPacket()) ||
+      current_incoming_packet_received_bytes_counted_) {
+    return;
+  }
+  // Only update bytes received if this probing frame is received on the most
+  // recent alternative path.
+  DCHECK(!IsDefaultPath(last_packet_destination_address_,
+                        GetEffectivePeerAddressFromCurrentPacket()));
+  if (!most_recent_alternative_path_.validated) {
+    most_recent_alternative_path_.bytes_received_before_address_validation_ +=
+        received_packet_size;
+  }
+  current_incoming_packet_received_bytes_counted_ = true;
+}
+
+bool QuicConnection::IsDefaultPath(
+    const QuicSocketAddress& self_address,
+    const QuicSocketAddress& peer_address) const {
+  return direct_peer_address_ == peer_address && self_address_ == self_address;
+}
+
+bool QuicConnection::IsMostRecentAlternativePath(
+    const QuicSocketAddress& self_address,
+    const QuicSocketAddress& peer_address) const {
+  return most_recent_alternative_path_.peer_address == peer_address &&
+         most_recent_alternative_path_.self_address == self_address;
+}
+
 #undef ENDPOINT  // undef for jumbo builds
 }  // namespace quic
diff --git a/quic/core/quic_connection.h b/quic/core/quic_connection.h
index 156a5c6..48b560f 100644
--- a/quic/core/quic_connection.h
+++ b/quic/core/quic_connection.h
@@ -1264,6 +1264,27 @@
  private:
   friend class test::QuicConnectionPeer;
 
+  struct QUIC_EXPORT_PRIVATE PendingPathChallenge {
+    QuicPathFrameBuffer received_path_challenge;
+    QuicSocketAddress peer_address;
+  };
+
+  struct QUIC_EXPORT_PRIVATE AlternativePathState {
+    AlternativePathState(const QuicSocketAddress& alternative_self_address,
+                         const QuicSocketAddress& alternative_peer_address)
+        : self_address(alternative_self_address),
+          peer_address(alternative_peer_address) {}
+
+    QuicSocketAddress self_address;
+    // The actual peer address behind the proxy if there is any.
+    QuicSocketAddress peer_address;
+    bool validated = false;
+    // Used by the sever to apply anti-amplification limit after this path
+    // becomes the default path if |peer_address| hasn't been validated.
+    QuicByteCount bytes_received_before_address_validation_ = 0;
+    QuicByteCount bytes_sent_before_address_validation_ = 0;
+  };
+
   using QueuedPacketList = std::list<SerializedPacket>;
 
   // BufferedPacket stores necessary information (encrypted buffer and self/peer
@@ -1542,7 +1563,7 @@
 
   // Called in IETF QUIC. Start peer migration if a non-probing frame is
   // received and the current packet number is largest received so far.
-  void MaybeStartIetfPeerMigration(QuicFrameType type);
+  void MaybeStartIetfPeerMigration();
 
   // Send PATH_RESPONSE to the given peer address.
   bool SendPathResponse(const QuicPathFrameBuffer& data_buffer,
@@ -1561,6 +1582,25 @@
                               const QuicSocketAddress& self_address,
                               const QuicSocketAddress& peer_address,
                               bool measure_rtt);
+
+  // Increment bytes sent/received on the most recent alternative path if the
+  // current packet is sent/received on that path.
+  void MaybeUpdateBytesSentToAlternativeAddress(
+      const QuicSocketAddress& peer_address,
+      QuicByteCount sent_packet_size);
+  void MaybeUpdateBytesReceivedFromAlternativeAddress(
+      QuicByteCount received_packet_size);
+
+  // Return true if the given self address and peer address is the same as the
+  // self address and peer address of the default path.
+  bool IsDefaultPath(const QuicSocketAddress& self_address,
+                     const QuicSocketAddress& peer_address) const;
+
+  // Return true if the given self address and peer address is the same as the
+  // self address and peer address of the most recent alternative path.
+  bool IsMostRecentAlternativePath(const QuicSocketAddress& self_address,
+                                   const QuicSocketAddress& peer_address) const;
+
   QuicFramer framer_;
 
   // Contents received in the current packet, especially used to identify
@@ -1866,8 +1906,7 @@
   // Buffer outstanding PATH_CHALLENGEs if socket write is blocked, future
   // OnCanWrite will attempt to respond with PATH_RESPONSEs using the retained
   // payload and peer addresses.
-  QuicCircularDeque<std::pair<QuicPathFrameBuffer, QuicSocketAddress>>
-      pending_path_challenge_payloads_;
+  QuicCircularDeque<PendingPathChallenge> pending_path_challenge_payloads_;
 
   // Set of connection IDs that should be accepted as destination on
   // received packets. This is conceptually a set but is implemented as a
@@ -1975,6 +2014,18 @@
   const bool use_encryption_level_context_;
 
   QuicPathValidator path_validator_;
+
+  // The most recent alternative path probed by an endpoint or its peer.
+  // It keeps track of the state of the probed path till it becomes the default
+  // path of the connection or replaced by a newer path under probing. The
+  // client starts to track it when it starts to validate the path. The server
+  // starts to track it when it receives a PATH_CHALLENGE in non-default path.
+  AlternativePathState most_recent_alternative_path_;
+
+  bool current_incoming_packet_received_bytes_counted_ = false;
+
+  bool count_bytes_on_alternative_path_seperately_ =
+      GetQuicReloadableFlag(quic_count_bytes_on_alternative_path_seperately);
 };
 
 }  // namespace quic
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index 7e75fa3..1baf44a 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -21,6 +21,7 @@
 #include "quic/core/crypto/quic_decrypter.h"
 #include "quic/core/crypto/quic_encrypter.h"
 #include "quic/core/frames/quic_connection_close_frame.h"
+#include "quic/core/frames/quic_path_response_frame.h"
 #include "quic/core/quic_connection_id.h"
 #include "quic/core/quic_constants.h"
 #include "quic/core/quic_error_codes.h"
@@ -1843,6 +1844,50 @@
   EXPECT_EQ(0u, connection_.GetStats().packets_discarded);
 }
 
+class TestQuicPathValidationContext : public QuicPathValidationContext {
+ public:
+  TestQuicPathValidationContext(const QuicSocketAddress& self_address,
+                                const QuicSocketAddress& peer_address,
+
+                                QuicPacketWriter* writer)
+      : QuicPathValidationContext(self_address, peer_address),
+        writer_(writer) {}
+
+  QuicPacketWriter* WriterToUse() override { return writer_; }
+
+ private:
+  QuicPacketWriter* writer_;
+};
+
+class TestValidationResultDelegate : public QuicPathValidator::ResultDelegate {
+ public:
+  TestValidationResultDelegate(const QuicSocketAddress& expected_self_address,
+                               const QuicSocketAddress& expected_peer_address,
+                               bool* success)
+      : QuicPathValidator::ResultDelegate(),
+        expected_self_address_(expected_self_address),
+        expected_peer_address_(expected_peer_address),
+        success_(success) {}
+  void OnPathValidationSuccess(
+      std::unique_ptr<QuicPathValidationContext> context) override {
+    EXPECT_EQ(expected_self_address_, context->self_address());
+    EXPECT_EQ(expected_peer_address_, context->peer_address());
+    *success_ = true;
+  }
+
+  void OnPathValidationFailure(
+      std::unique_ptr<QuicPathValidationContext> context) override {
+    EXPECT_EQ(expected_self_address_, context->self_address());
+    EXPECT_EQ(expected_peer_address_, context->peer_address());
+    *success_ = false;
+  }
+
+ private:
+  QuicSocketAddress expected_self_address_;
+  QuicSocketAddress expected_peer_address_;
+  bool* success_;
+};
+
 // Receive a path probe request at the server side, i.e.,
 // in non-IETF version: receive a padded PING packet with a peer addess change;
 // in IETF version: receive a packet contains PATH CHALLENGE with peer address
@@ -1868,7 +1913,6 @@
       QuicEncryptedPacket(probing_packet->encrypted_buffer,
                           probing_packet->encrypted_length),
       clock_.Now()));
-
   uint64_t num_probing_received =
       connection_.GetStats().num_connectivity_probing_received;
   ProcessReceivedPacket(kSelfAddress, kNewPeerAddress, *received);
@@ -1877,6 +1921,58 @@
             connection_.GetStats().num_connectivity_probing_received);
   EXPECT_EQ(kPeerAddress, connection_.peer_address());
   EXPECT_EQ(kPeerAddress, connection_.effective_peer_address());
+  if (GetParam().version.HasIetfQuicFrames() &&
+      connection_.use_path_validator() &&
+      GetQuicReloadableFlag(quic_count_bytes_on_alternative_path_seperately)) {
+    QuicByteCount bytes_sent =
+        QuicConnectionPeer::BytesSentOnMostRecentAlternativePath(&connection_);
+    EXPECT_LT(0u, bytes_sent);
+    EXPECT_EQ(received->length(),
+              QuicConnectionPeer::BytesReceivedOnMostRecentAlternativePath(
+                  &connection_));
+
+    // Receiving one more probing packet should update the bytes count.
+    probing_packet = ConstructProbingPacket();
+    received.reset(ConstructReceivedPacket(
+        QuicEncryptedPacket(probing_packet->encrypted_buffer,
+                            probing_packet->encrypted_length),
+        clock_.Now()));
+    ProcessReceivedPacket(kSelfAddress, kNewPeerAddress, *received);
+
+    EXPECT_EQ(num_probing_received + 2,
+              connection_.GetStats().num_connectivity_probing_received);
+    EXPECT_EQ(
+        2 * bytes_sent,
+        QuicConnectionPeer::BytesSentOnMostRecentAlternativePath(&connection_));
+    EXPECT_EQ(2 * received->length(),
+              QuicConnectionPeer::BytesReceivedOnMostRecentAlternativePath(
+                  &connection_));
+
+    EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
+        .Times(AtLeast(1u))
+        .WillOnce(Invoke(
+            [&]() { EXPECT_EQ(1u, writer_->path_challenge_frames().size()); }));
+
+    bool success = false;
+    connection_.ValidatePath(
+        std::make_unique<TestQuicPathValidationContext>(
+            connection_.self_address(), kNewPeerAddress, writer_.get()),
+        std::make_unique<TestValidationResultDelegate>(
+            connection_.self_address(), kNewPeerAddress, &success));
+    EXPECT_EQ(
+        3 * bytes_sent,
+        QuicConnectionPeer::BytesSentOnMostRecentAlternativePath(&connection_));
+
+    QuicFrames frames;
+    frames.push_back(QuicFrame(new QuicPathResponseFrame(
+        99, writer_->path_challenge_frames().front().data_buffer)));
+    ProcessFramesPacketWithAddresses(frames, connection_.self_address(),
+                                     kNewPeerAddress,
+                                     ENCRYPTION_FORWARD_SECURE);
+    EXPECT_EQ(3 * received->length(),
+              QuicConnectionPeer::BytesReceivedOnMostRecentAlternativePath(
+                  &connection_));
+  }
 
   // Process another packet with the old peer address on server side will not
   // start peer migration.
@@ -11074,50 +11170,6 @@
   EXPECT_TRUE(connection_.connected());
 }
 
-class TestQuicPathValidationContext : public QuicPathValidationContext {
- public:
-  TestQuicPathValidationContext(const QuicSocketAddress& self_address,
-                                const QuicSocketAddress& peer_address,
-
-                                QuicPacketWriter* writer)
-      : QuicPathValidationContext(self_address, peer_address),
-        writer_(writer) {}
-
-  QuicPacketWriter* WriterToUse() override { return writer_; }
-
- private:
-  QuicPacketWriter* writer_;
-};
-
-class TestValidationResultDelegate : public QuicPathValidator::ResultDelegate {
- public:
-  TestValidationResultDelegate(const QuicSocketAddress& expected_self_address,
-                               const QuicSocketAddress& expected_peer_address,
-                               bool* success)
-      : QuicPathValidator::ResultDelegate(),
-        expected_self_address_(expected_self_address),
-        expected_peer_address_(expected_peer_address),
-        success_(success) {}
-  void OnPathValidationSuccess(
-      std::unique_ptr<QuicPathValidationContext> context) override {
-    EXPECT_EQ(expected_self_address_, context->self_address());
-    EXPECT_EQ(expected_peer_address_, context->peer_address());
-    *success_ = true;
-  }
-
-  void OnPathValidationFailure(
-      std::unique_ptr<QuicPathValidationContext> context) override {
-    EXPECT_EQ(expected_self_address_, context->self_address());
-    EXPECT_EQ(expected_peer_address_, context->peer_address());
-    *success_ = false;
-  }
-
- private:
-  QuicSocketAddress expected_self_address_;
-  QuicSocketAddress expected_peer_address_;
-  bool* success_;
-};
-
 TEST_P(QuicConnectionTest, PathValidationOnNewSocketSuccess) {
   if (!VersionHasIetfQuicFrames(connection_.version().transport_version) ||
       !connection_.use_path_validator()) {
@@ -11197,7 +11249,7 @@
       !connection_.send_path_response()) {
     return;
   }
-  PathProbeTestInit(Perspective::IS_SERVER);
+  PathProbeTestInit(Perspective::IS_CLIENT);
   if (version().SupportsAntiAmplificationLimit()) {
     QuicConnectionPeer::SetAddressValidated(&connection_);
   }
@@ -11319,7 +11371,7 @@
       !connection_.use_path_validator()) {
     return;
   }
-  PathProbeTestInit(Perspective::IS_SERVER);
+  PathProbeTestInit(Perspective::IS_CLIENT);
 
   writer_->SetShouldWriteFail();
   const QuicSocketAddress kNewPeerAddress(QuicIpAddress::Any4(), 12345);
@@ -11351,7 +11403,7 @@
       !connection_.use_path_validator()) {
     return;
   }
-  PathProbeTestInit(Perspective::IS_SERVER);
+  PathProbeTestInit(Perspective::IS_CLIENT);
 
   writer_->SetShouldWriteFail();
   writer_->SetWriteError(EMSGSIZE);
@@ -11616,8 +11668,7 @@
                                    ENCRYPTION_FORWARD_SECURE);
 
   EXPECT_EQ(
-      1u,
-      QuicConnectionPeer::pending_path_challenge_payloads(&connection_).size());
+      1u, QuicConnectionPeer::NumPendingPathChallengesToResponse(&connection_));
 
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(AtLeast(1));
   writer_->SetWritable();
@@ -11632,8 +11683,8 @@
   // PATH_RESPONSE should be sent in another packet to a different peer
   // address.
   EXPECT_EQ(kNewPeerAddress, writer_->last_write_peer_address());
-  EXPECT_TRUE(QuicConnectionPeer::pending_path_challenge_payloads(&connection_)
-                  .empty());
+  EXPECT_EQ(
+      0u, QuicConnectionPeer::NumPendingPathChallengesToResponse(&connection_));
 }
 
 // Regression test for b/168101557.
diff --git a/quic/core/quic_flags_list.h b/quic/core/quic_flags_list.h
index 04a2244..1397140 100644
--- a/quic/core/quic_flags_list.h
+++ b/quic/core/quic_flags_list.h
@@ -20,6 +20,7 @@
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_close_connection_on_0rtt_packet_number_higher_than_1rtt, false)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_conservative_bursts, false)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_conservative_cwnd_and_pacing_gains, false)
+QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_count_bytes_on_alternative_path_seperately, false)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_default_enable_5rto_blackhole_detection2, true)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_default_on_pto, false)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_default_to_bbr, false)
diff --git a/quic/core/quic_packet_creator.h b/quic/core/quic_packet_creator.h
index 3628908..5e0c65e 100644
--- a/quic/core/quic_packet_creator.h
+++ b/quic/core/quic_packet_creator.h
@@ -471,6 +471,8 @@
   // Return true if retry_token_ is not empty.
   bool HasRetryToken() const;
 
+  const QuicSocketAddress& peer_address() const { return packet_.peer_address; }
+
  private:
   friend class test::QuicPacketCreatorPeer;
 
diff --git a/quic/test_tools/quic_connection_peer.cc b/quic/test_tools/quic_connection_peer.cc
index fa99133..4989612 100644
--- a/quic/test_tools/quic_connection_peer.cc
+++ b/quic/test_tools/quic_connection_peer.cc
@@ -9,6 +9,7 @@
 #include "quic/core/quic_packet_writer.h"
 #include "quic/core/quic_received_packet_manager.h"
 #include "quic/platform/api/quic_flags.h"
+#include "quic/platform/api/quic_socket_address.h"
 #include "quic/test_tools/quic_framer_peer.h"
 #include "quic/test_tools/quic_sent_packet_manager_peer.h"
 
@@ -384,10 +385,9 @@
 }
 
 // static
-const QuicCircularDeque<std::pair<QuicPathFrameBuffer, QuicSocketAddress>>&
-QuicConnectionPeer::pending_path_challenge_payloads(
+size_t QuicConnectionPeer::NumPendingPathChallengesToResponse(
     QuicConnection* connection) {
-  return connection->pending_path_challenge_payloads_;
+  return connection->pending_path_challenge_payloads_.size();
 }
 
 void QuicConnectionPeer::SetConnectionClose(QuicConnection* connection) {
@@ -412,5 +412,19 @@
   return &connection->path_validator_;
 }
 
+//  static
+QuicByteCount QuicConnectionPeer::BytesSentOnMostRecentAlternativePath(
+    QuicConnection* connection) {
+  return connection->most_recent_alternative_path_
+      .bytes_sent_before_address_validation_;
+}
+
+//  static
+QuicByteCount QuicConnectionPeer::BytesReceivedOnMostRecentAlternativePath(
+    QuicConnection* connection) {
+  return connection->most_recent_alternative_path_
+      .bytes_sent_before_address_validation_;
+}
+
 }  // namespace test
 }  // namespace quic
diff --git a/quic/test_tools/quic_connection_peer.h b/quic/test_tools/quic_connection_peer.h
index 5b077b5..2795531 100644
--- a/quic/test_tools/quic_connection_peer.h
+++ b/quic/test_tools/quic_connection_peer.h
@@ -5,10 +5,12 @@
 #ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_CONNECTION_PEER_H_
 #define QUICHE_QUIC_TEST_TOOLS_QUIC_CONNECTION_PEER_H_
 
+#include <cstddef>
 #include "absl/strings/string_view.h"
 #include "quic/core/quic_connection.h"
 #include "quic/core/quic_connection_stats.h"
 #include "quic/core/quic_packets.h"
+#include "quic/core/quic_types.h"
 #include "quic/platform/api/quic_socket_address.h"
 
 namespace quic {
@@ -158,9 +160,7 @@
 
   static size_t NumUndecryptablePackets(QuicConnection* connection);
 
-  static const QuicCircularDeque<
-      std::pair<QuicPathFrameBuffer, QuicSocketAddress>>&
-  pending_path_challenge_payloads(QuicConnection* connection);
+  static size_t NumPendingPathChallengesToResponse(QuicConnection* connection);
 
   static void SetConnectionClose(QuicConnection* connection);
 
@@ -170,6 +170,12 @@
                                               const QuicSocketAddress& address);
 
   static QuicPathValidator* path_validator(QuicConnection* connection);
+
+  static QuicByteCount BytesSentOnMostRecentAlternativePath(
+      QuicConnection* connection);
+
+  static QuicByteCount BytesReceivedOnMostRecentAlternativePath(
+      QuicConnection* connection);
 };
 
 }  // namespace test