diff --git a/quiche/quic/core/congestion_control/bbr2_misc.cc b/quiche/quic/core/congestion_control/bbr2_misc.cc
index 7aab8ed..43c6f8c 100644
--- a/quiche/quic/core/congestion_control/bbr2_misc.cc
+++ b/quiche/quic/core/congestion_control/bbr2_misc.cc
@@ -18,6 +18,24 @@
 
 namespace quic {
 
+const char* ProbePhaseToString(ProbePhase phase) {
+  switch (phase) {
+    case ProbePhase::PROBE_NOT_STARTED:
+      return "PROBE_NOT_STARTED";
+    case ProbePhase::PROBE_UP:
+      return "PROBE_UP";
+    case ProbePhase::PROBE_DOWN:
+      return "PROBE_DOWN";
+    case ProbePhase::PROBE_CRUISE:
+      return "PROBE_CRUISE";
+    case ProbePhase::PROBE_REFILL:
+      return "PROBE_REFILL";
+    default:
+      break;
+  }
+  return "<Invalid ProbePhase>";
+}
+
 RoundTripCounter::RoundTripCounter() : round_trip_count_(0) {}
 
 void RoundTripCounter::OnPacketSent(QuicPacketNumber packet_number) {
diff --git a/quiche/quic/core/congestion_control/bbr2_misc.h b/quiche/quic/core/congestion_control/bbr2_misc.h
index 84ba709..d57b6be 100644
--- a/quiche/quic/core/congestion_control/bbr2_misc.h
+++ b/quiche/quic/core/congestion_control/bbr2_misc.h
@@ -226,6 +226,21 @@
   bool decrease_startup_pacing_at_end_of_round = false;
 };
 
+enum class ProbePhase : uint8_t {
+  PROBE_NOT_STARTED,
+  PROBE_UP,
+  PROBE_DOWN,
+  PROBE_CRUISE,
+  PROBE_REFILL,
+};
+
+QUICHE_EXPORT const char* ProbePhaseToString(ProbePhase phase);
+
+QUICHE_EXPORT inline std::ostream& operator<<(std::ostream& os,
+                                              ProbePhase phase) {
+  return os << ProbePhaseToString(phase);
+}
+
 class QUICHE_EXPORT RoundTripCounter {
  public:
   RoundTripCounter();
diff --git a/quiche/quic/core/congestion_control/bbr2_probe_bw.cc b/quiche/quic/core/congestion_control/bbr2_probe_bw.cc
index 369b339..d15617b 100644
--- a/quiche/quic/core/congestion_control/bbr2_probe_bw.cc
+++ b/quiche/quic/core/congestion_control/bbr2_probe_bw.cc
@@ -20,19 +20,19 @@
 
 void Bbr2ProbeBwMode::Enter(QuicTime now,
                             const Bbr2CongestionEvent* /*congestion_event*/) {
-  if (cycle_.phase == CyclePhase::PROBE_NOT_STARTED) {
+  if (cycle_.phase == ProbePhase::PROBE_NOT_STARTED) {
     // First time entering PROBE_BW. Start a new probing cycle.
     EnterProbeDown(/*probed_too_high=*/false, /*stopped_risky_probe=*/false,
                    now);
   } else {
     // Transitioning from PROBE_RTT to PROBE_BW. Re-enter the last phase before
     // PROBE_RTT.
-    QUICHE_DCHECK(cycle_.phase == CyclePhase::PROBE_CRUISE ||
-                  cycle_.phase == CyclePhase::PROBE_REFILL);
+    QUICHE_DCHECK(cycle_.phase == ProbePhase::PROBE_CRUISE ||
+                  cycle_.phase == ProbePhase::PROBE_REFILL);
     cycle_.cycle_start_time = now;
-    if (cycle_.phase == CyclePhase::PROBE_CRUISE) {
+    if (cycle_.phase == ProbePhase::PROBE_CRUISE) {
       EnterProbeCruise(now);
-    } else if (cycle_.phase == CyclePhase::PROBE_REFILL) {
+    } else if (cycle_.phase == ProbePhase::PROBE_REFILL) {
       EnterProbeRefill(cycle_.probe_up_rounds, now);
     }
   }
@@ -43,7 +43,7 @@
     const AckedPacketVector& /*acked_packets*/,
     const LostPacketVector& /*lost_packets*/,
     const Bbr2CongestionEvent& congestion_event) {
-  QUICHE_DCHECK_NE(cycle_.phase, CyclePhase::PROBE_NOT_STARTED);
+  QUICHE_DCHECK_NE(cycle_.phase, ProbePhase::PROBE_NOT_STARTED);
 
   if (congestion_event.end_of_round_trip) {
     if (cycle_.cycle_start_time != event_time) {
@@ -56,18 +56,18 @@
 
   bool switch_to_probe_rtt = false;
 
-  if (cycle_.phase == CyclePhase::PROBE_UP) {
+  if (cycle_.phase == ProbePhase::PROBE_UP) {
     UpdateProbeUp(prior_in_flight, congestion_event);
-  } else if (cycle_.phase == CyclePhase::PROBE_DOWN) {
+  } else if (cycle_.phase == ProbePhase::PROBE_DOWN) {
     UpdateProbeDown(prior_in_flight, congestion_event);
     // Maybe transition to PROBE_RTT at the end of this cycle.
-    if (cycle_.phase != CyclePhase::PROBE_DOWN &&
+    if (cycle_.phase != ProbePhase::PROBE_DOWN &&
         model_->MaybeExpireMinRtt(congestion_event)) {
       switch_to_probe_rtt = true;
     }
-  } else if (cycle_.phase == CyclePhase::PROBE_CRUISE) {
+  } else if (cycle_.phase == ProbePhase::PROBE_CRUISE) {
     UpdateProbeCruise(congestion_event);
-  } else if (cycle_.phase == CyclePhase::PROBE_REFILL) {
+  } else if (cycle_.phase == ProbePhase::PROBE_REFILL) {
     UpdateProbeRefill(congestion_event);
   }
 
@@ -82,12 +82,12 @@
 }
 
 Limits<QuicByteCount> Bbr2ProbeBwMode::GetCwndLimits() const {
-  if (cycle_.phase == CyclePhase::PROBE_CRUISE) {
+  if (cycle_.phase == ProbePhase::PROBE_CRUISE) {
     return NoGreaterThan(
         std::min(model_->inflight_lo(), model_->inflight_hi_with_headroom()));
   }
   if (Params().probe_up_ignore_inflight_hi &&
-      cycle_.phase == CyclePhase::PROBE_UP) {
+      cycle_.phase == ProbePhase::PROBE_UP) {
     // Similar to STARTUP.
     return NoGreaterThan(model_->inflight_lo());
   }
@@ -96,8 +96,8 @@
 }
 
 bool Bbr2ProbeBwMode::IsProbingForBandwidth() const {
-  return cycle_.phase == CyclePhase::PROBE_REFILL ||
-         cycle_.phase == CyclePhase::PROBE_UP;
+  return cycle_.phase == ProbePhase::PROBE_REFILL ||
+         cycle_.phase == ProbePhase::PROBE_UP;
 }
 
 Bbr2Mode Bbr2ProbeBwMode::OnExitQuiescence(QuicTime now,
@@ -113,7 +113,7 @@
 void Bbr2ProbeBwMode::UpdateProbeDown(
     QuicByteCount prior_in_flight,
     const Bbr2CongestionEvent& congestion_event) {
-  QUICHE_DCHECK_EQ(cycle_.phase, CyclePhase::PROBE_DOWN);
+  QUICHE_DCHECK_EQ(cycle_.phase, ProbePhase::PROBE_DOWN);
 
   if (cycle_.rounds_in_phase == 1 && congestion_event.end_of_round_trip) {
     cycle_.is_sample_from_probing = false;
@@ -331,7 +331,7 @@
 }
 
 void Bbr2ProbeBwMode::RaiseInflightHighSlope() {
-  QUICHE_DCHECK_EQ(cycle_.phase, CyclePhase::PROBE_UP);
+  QUICHE_DCHECK_EQ(cycle_.phase, ProbePhase::PROBE_UP);
   uint64_t growth_this_round = 1 << cycle_.probe_up_rounds;
   // The number 30 below means |growth_this_round| is capped at 1G and the lower
   // bound of |probe_up_bytes| is (practically) 1 mss, at this speed inflight_hi
@@ -347,7 +347,7 @@
 
 void Bbr2ProbeBwMode::ProbeInflightHighUpward(
     const Bbr2CongestionEvent& congestion_event) {
-  QUICHE_DCHECK_EQ(cycle_.phase, CyclePhase::PROBE_UP);
+  QUICHE_DCHECK_EQ(cycle_.phase, ProbePhase::PROBE_UP);
   if (Params().probe_up_ignore_inflight_hi) {
     // When inflight_hi is disabled in PROBE_UP, it increases when
     // the number of bytes delivered in a round is larger inflight_hi.
@@ -412,7 +412,7 @@
 
 void Bbr2ProbeBwMode::UpdateProbeCruise(
     const Bbr2CongestionEvent& congestion_event) {
-  QUICHE_DCHECK_EQ(cycle_.phase, CyclePhase::PROBE_CRUISE);
+  QUICHE_DCHECK_EQ(cycle_.phase, ProbePhase::PROBE_CRUISE);
   MaybeAdaptUpperBounds(congestion_event);
   QUICHE_DCHECK(!cycle_.is_sample_from_probing);
 
@@ -424,7 +424,7 @@
 
 void Bbr2ProbeBwMode::UpdateProbeRefill(
     const Bbr2CongestionEvent& congestion_event) {
-  QUICHE_DCHECK_EQ(cycle_.phase, CyclePhase::PROBE_REFILL);
+  QUICHE_DCHECK_EQ(cycle_.phase, ProbePhase::PROBE_REFILL);
   MaybeAdaptUpperBounds(congestion_event);
   QUICHE_DCHECK(!cycle_.is_sample_from_probing);
 
@@ -437,7 +437,7 @@
 void Bbr2ProbeBwMode::UpdateProbeUp(
     QuicByteCount prior_in_flight,
     const Bbr2CongestionEvent& congestion_event) {
-  QUICHE_DCHECK_EQ(cycle_.phase, CyclePhase::PROBE_UP);
+  QUICHE_DCHECK_EQ(cycle_.phase, ProbePhase::PROBE_UP);
   if (MaybeAdaptUpperBounds(congestion_event) == ADAPTED_PROBED_TOO_HIGH) {
     EnterProbeDown(/*probed_too_high=*/true, /*stopped_risky_probe=*/false,
                    congestion_event.event_time);
@@ -501,7 +501,7 @@
 void Bbr2ProbeBwMode::EnterProbeDown(bool probed_too_high,
                                      bool stopped_risky_probe, QuicTime now) {
   QUIC_DVLOG(2) << sender_ << " Phase change: " << cycle_.phase << " ==> "
-                << CyclePhase::PROBE_DOWN << " after "
+                << ProbePhase::PROBE_DOWN << " after "
                 << now - cycle_.phase_start_time << ", or "
                 << cycle_.rounds_in_phase
                 << " rounds. probed_too_high:" << probed_too_high
@@ -511,7 +511,7 @@
   last_cycle_stopped_risky_probe_ = stopped_risky_probe;
 
   cycle_.cycle_start_time = now;
-  cycle_.phase = CyclePhase::PROBE_DOWN;
+  cycle_.phase = ProbePhase::PROBE_DOWN;
   cycle_.rounds_in_phase = 0;
   cycle_.phase_start_time = now;
   ++sender_->connection_stats_->bbr_num_cycles;
@@ -538,32 +538,32 @@
 }
 
 void Bbr2ProbeBwMode::EnterProbeCruise(QuicTime now) {
-  if (cycle_.phase == CyclePhase::PROBE_DOWN) {
+  if (cycle_.phase == ProbePhase::PROBE_DOWN) {
     ExitProbeDown();
   }
   QUIC_DVLOG(2) << sender_ << " Phase change: " << cycle_.phase << " ==> "
-                << CyclePhase::PROBE_CRUISE << " after "
+                << ProbePhase::PROBE_CRUISE << " after "
                 << now - cycle_.phase_start_time << ", or "
                 << cycle_.rounds_in_phase << " rounds.  @ " << now;
 
   model_->cap_inflight_lo(model_->inflight_hi());
-  cycle_.phase = CyclePhase::PROBE_CRUISE;
+  cycle_.phase = ProbePhase::PROBE_CRUISE;
   cycle_.rounds_in_phase = 0;
   cycle_.phase_start_time = now;
   cycle_.is_sample_from_probing = false;
 }
 
 void Bbr2ProbeBwMode::EnterProbeRefill(uint64_t probe_up_rounds, QuicTime now) {
-  if (cycle_.phase == CyclePhase::PROBE_DOWN) {
+  if (cycle_.phase == ProbePhase::PROBE_DOWN) {
     ExitProbeDown();
   }
   QUIC_DVLOG(2) << sender_ << " Phase change: " << cycle_.phase << " ==> "
-                << CyclePhase::PROBE_REFILL << " after "
+                << ProbePhase::PROBE_REFILL << " after "
                 << now - cycle_.phase_start_time << ", or "
                 << cycle_.rounds_in_phase
                 << " rounds. probe_up_rounds:" << probe_up_rounds << "  @ "
                 << now;
-  cycle_.phase = CyclePhase::PROBE_REFILL;
+  cycle_.phase = ProbePhase::PROBE_REFILL;
   cycle_.rounds_in_phase = 0;
   cycle_.phase_start_time = now;
   cycle_.is_sample_from_probing = false;
@@ -577,12 +577,12 @@
 }
 
 void Bbr2ProbeBwMode::EnterProbeUp(QuicTime now) {
-  QUICHE_DCHECK_EQ(cycle_.phase, CyclePhase::PROBE_REFILL);
+  QUICHE_DCHECK_EQ(cycle_.phase, ProbePhase::PROBE_REFILL);
   QUIC_DVLOG(2) << sender_ << " Phase change: " << cycle_.phase << " ==> "
-                << CyclePhase::PROBE_UP << " after "
+                << ProbePhase::PROBE_UP << " after "
                 << now - cycle_.phase_start_time << ", or "
                 << cycle_.rounds_in_phase << " rounds.  @ " << now;
-  cycle_.phase = CyclePhase::PROBE_UP;
+  cycle_.phase = ProbePhase::PROBE_UP;
   cycle_.rounds_in_phase = 0;
   cycle_.phase_start_time = now;
   cycle_.is_sample_from_probing = true;
@@ -592,7 +592,7 @@
 }
 
 void Bbr2ProbeBwMode::ExitProbeDown() {
-  QUICHE_DCHECK_EQ(cycle_.phase, CyclePhase::PROBE_DOWN);
+  QUICHE_DCHECK_EQ(cycle_.phase, ProbePhase::PROBE_DOWN);
   if (!cycle_.has_advanced_max_bw) {
     QUIC_DVLOG(2) << sender_ << " Advancing max bw filter at end of cycle.";
     model_->AdvanceMaxBandwidthFilter();
@@ -600,29 +600,7 @@
   }
 }
 
-// static
-const char* Bbr2ProbeBwMode::CyclePhaseToString(CyclePhase phase) {
-  switch (phase) {
-    case CyclePhase::PROBE_NOT_STARTED:
-      return "PROBE_NOT_STARTED";
-    case CyclePhase::PROBE_UP:
-      return "PROBE_UP";
-    case CyclePhase::PROBE_DOWN:
-      return "PROBE_DOWN";
-    case CyclePhase::PROBE_CRUISE:
-      return "PROBE_CRUISE";
-    case CyclePhase::PROBE_REFILL:
-      return "PROBE_REFILL";
-    default:
-      break;
-  }
-  return "<Invalid CyclePhase>";
-}
 
-std::ostream& operator<<(std::ostream& os,
-                         const Bbr2ProbeBwMode::CyclePhase phase) {
-  return os << Bbr2ProbeBwMode::CyclePhaseToString(phase);
-}
 
 Bbr2ProbeBwMode::DebugState Bbr2ProbeBwMode::ExportDebugState() const {
   DebugState s;
@@ -642,12 +620,11 @@
 
 const Bbr2Params& Bbr2ProbeBwMode::Params() const { return sender_->Params(); }
 
-float Bbr2ProbeBwMode::PacingGainForPhase(
-    Bbr2ProbeBwMode::CyclePhase phase) const {
-  if (phase == Bbr2ProbeBwMode::CyclePhase::PROBE_UP) {
+float Bbr2ProbeBwMode::PacingGainForPhase(ProbePhase phase) const {
+  if (phase == ProbePhase::PROBE_UP) {
     return Params().probe_bw_probe_up_pacing_gain;
   }
-  if (phase == Bbr2ProbeBwMode::CyclePhase::PROBE_DOWN) {
+  if (phase == ProbePhase::PROBE_DOWN) {
     return Params().probe_bw_probe_down_pacing_gain;
   }
   return Params().probe_bw_default_pacing_gain;
diff --git a/quiche/quic/core/congestion_control/bbr2_probe_bw.h b/quiche/quic/core/congestion_control/bbr2_probe_bw.h
index b5a1703..83c5764 100644
--- a/quiche/quic/core/congestion_control/bbr2_probe_bw.h
+++ b/quiche/quic/core/congestion_control/bbr2_probe_bw.h
@@ -38,18 +38,9 @@
   Bbr2Mode OnExitQuiescence(QuicTime now,
                             QuicTime quiescence_start_time) override;
 
-  enum class CyclePhase : uint8_t {
-    PROBE_NOT_STARTED,
-    PROBE_UP,
-    PROBE_DOWN,
-    PROBE_CRUISE,
-    PROBE_REFILL,
-  };
-
-  static const char* CyclePhaseToString(CyclePhase phase);
 
   struct QUICHE_EXPORT DebugState {
-    CyclePhase phase;
+    ProbePhase phase;
     QuicTime cycle_start_time = QuicTime::Zero();
     QuicTime phase_start_time = QuicTime::Zero();
   };
@@ -58,7 +49,7 @@
 
  private:
   const Bbr2Params& Params() const;
-  float PacingGainForPhase(CyclePhase phase) const;
+  float PacingGainForPhase(ProbePhase phase) const;
 
   void UpdateProbeUp(QuicByteCount prior_in_flight,
                      const Bbr2CongestionEvent& congestion_event);
@@ -108,7 +99,7 @@
 
   struct QUICHE_EXPORT Cycle {
     QuicTime cycle_start_time = QuicTime::Zero();
-    CyclePhase phase = CyclePhase::PROBE_NOT_STARTED;
+    ProbePhase phase = ProbePhase::PROBE_NOT_STARTED;
     uint64_t rounds_in_phase = 0;
     QuicTime phase_start_time = QuicTime::Zero();
     QuicRoundTripCount rounds_since_probe = 0;
@@ -130,9 +121,6 @@
 QUICHE_EXPORT std::ostream& operator<<(
     std::ostream& os, const Bbr2ProbeBwMode::DebugState& state);
 
-QUICHE_EXPORT std::ostream& operator<<(std::ostream& os,
-                                       const Bbr2ProbeBwMode::CyclePhase phase);
-
 }  // namespace quic
 
 #endif  // QUICHE_QUIC_CORE_CONGESTION_CONTROL_BBR2_PROBE_BW_H_
diff --git a/quiche/quic/core/congestion_control/bbr2_simulator_test.cc b/quiche/quic/core/congestion_control/bbr2_simulator_test.cc
index 205f102..6214aff 100644
--- a/quiche/quic/core/congestion_control/bbr2_simulator_test.cc
+++ b/quiche/quic/core/congestion_control/bbr2_simulator_test.cc
@@ -48,7 +48,6 @@
 
 namespace quic {
 
-using CyclePhase = Bbr2ProbeBwMode::CyclePhase;
 
 namespace test {
 
@@ -1549,7 +1548,7 @@
         QuicRoundTripCount rounds_passed =
             debug_state.round_trip_count - start_round_trip;
         return rounds_passed >= 4 && debug_state.mode == Bbr2Mode::PROBE_BW &&
-               debug_state.probe_bw.phase == CyclePhase::PROBE_REFILL;
+               debug_state.probe_bw.phase == ProbePhase::PROBE_REFILL;
       },
       timeout);
   ASSERT_TRUE(simulator_result);
@@ -1573,7 +1572,7 @@
   simulator_result = SendUntilOrTimeout(
       [this]() {
         return sender_->ExportDebugState().probe_bw.phase ==
-               CyclePhase::PROBE_REFILL;
+               ProbePhase::PROBE_REFILL;
       },
       timeout);
   ASSERT_TRUE(simulator_result);
@@ -1585,7 +1584,7 @@
   for (int i = 0; i < 2; i++) {
     SendBursts(params, 5, target_bandwidth * burst_interval, burst_interval);
     EXPECT_EQ(Bbr2Mode::PROBE_BW, sender_->ExportDebugState().mode);
-    EXPECT_EQ(CyclePhase::PROBE_UP, sender_->ExportDebugState().probe_bw.phase);
+    EXPECT_EQ(ProbePhase::PROBE_UP, sender_->ExportDebugState().probe_bw.phase);
     EXPECT_APPROX_EQ(params.BottleneckBandwidth(),
                      sender_->ExportDebugState().bandwidth_hi, 0.02f);
   }
@@ -1604,13 +1603,13 @@
   simulator_result = simulator_.RunUntilOrTimeout(
       [this]() {
         return sender_->ExportDebugState().probe_bw.phase ==
-               CyclePhase::PROBE_DOWN;
+               ProbePhase::PROBE_DOWN;
       },
       timeout);
   ASSERT_TRUE(simulator_result);
   simulator_.RunFor(0.75 * sender_->ExportDebugState().min_rtt);
   EXPECT_EQ(Bbr2Mode::PROBE_BW, sender_->ExportDebugState().mode);
-  EXPECT_EQ(CyclePhase::PROBE_CRUISE,
+  EXPECT_EQ(ProbePhase::PROBE_CRUISE,
             sender_->ExportDebugState().probe_bw.phase);
 }
 
@@ -1775,7 +1774,7 @@
   sender_->OnCongestionEvent(
       /*rtt_updated=*/true, sender_unacked_map()->bytes_in_flight(), now,
       acked_packets, {}, 0, 0);
-  ASSERT_EQ(CyclePhase::PROBE_REFILL,
+  ASSERT_EQ(ProbePhase::PROBE_REFILL,
             sender_->ExportDebugState().probe_bw.phase);
 
   // Send and Ack one packet to exit app limited and enter PROBE_UP.
@@ -1786,7 +1785,7 @@
       /*rtt_updated=*/true, kDefaultMaxPacketSize, now,
       {AckedPacket(next_packet_number - 1, kDefaultMaxPacketSize, now)}, {}, 0,
       0);
-  ASSERT_EQ(CyclePhase::PROBE_UP, sender_->ExportDebugState().probe_bw.phase);
+  ASSERT_EQ(ProbePhase::PROBE_UP, sender_->ExportDebugState().probe_bw.phase);
 
   // Send 2 packets and lose the first one(50% loss) to exit PROBE_UP.
   for (uint64_t i = 0; i < 2; ++i) {
@@ -1940,7 +1939,7 @@
   simulator_result = SendUntilOrTimeout(
       [this]() {
         return sender_->ExportDebugState().probe_bw.phase ==
-               CyclePhase::PROBE_REFILL;
+               ProbePhase::PROBE_REFILL;
       },
       timeout);
   ASSERT_TRUE(simulator_result);