diff --git a/quic/core/quic_bandwidth.cc b/quic/core/quic_bandwidth.cc
index a1dbf67..9fcc3b9 100644
--- a/quic/core/quic_bandwidth.cc
+++ b/quic/core/quic_bandwidth.cc
@@ -11,7 +11,7 @@
 
 namespace quic {
 
-std::string QuicBandwidth::ToDebugValue() const {
+std::string QuicBandwidth::ToDebuggingValue() const {
   if (bits_per_second_ < 80000) {
     return QuicStringPrintf("%" PRId64 " bits/s (%" PRId64 " bytes/s)",
                             bits_per_second_, bits_per_second_ / 8);
diff --git a/quic/core/quic_bandwidth.h b/quic/core/quic_bandwidth.h
index fe043b0..a5bb306 100644
--- a/quic/core/quic_bandwidth.h
+++ b/quic/core/quic_bandwidth.h
@@ -89,7 +89,7 @@
                                              bits_per_second_);
   }
 
-  std::string ToDebugValue() const;
+  std::string ToDebuggingValue() const;
 
  private:
   explicit constexpr QuicBandwidth(int64_t bits_per_second)
@@ -146,7 +146,7 @@
 // Override stream output operator for gtest.
 inline std::ostream& operator<<(std::ostream& output,
                                 const QuicBandwidth bandwidth) {
-  output << bandwidth.ToDebugValue();
+  output << bandwidth.ToDebuggingValue();
   return output;
 }
 
diff --git a/quic/core/quic_bandwidth_test.cc b/quic/core/quic_bandwidth_test.cc
index 7f9535e..22a5107 100644
--- a/quic/core/quic_bandwidth_test.cc
+++ b/quic/core/quic_bandwidth_test.cc
@@ -105,20 +105,20 @@
   EXPECT_GE(b2, b1);
 }
 
-TEST_F(QuicBandwidthTest, DebugValue) {
+TEST_F(QuicBandwidthTest, DebuggingValue) {
   EXPECT_EQ("128 bits/s (16 bytes/s)",
-            QuicBandwidth::FromBytesPerSecond(16).ToDebugValue());
+            QuicBandwidth::FromBytesPerSecond(16).ToDebuggingValue());
   EXPECT_EQ("4096 bits/s (512 bytes/s)",
-            QuicBandwidth::FromBytesPerSecond(512).ToDebugValue());
+            QuicBandwidth::FromBytesPerSecond(512).ToDebuggingValue());
 
   QuicBandwidth bandwidth = QuicBandwidth::FromBytesPerSecond(1000 * 50);
-  EXPECT_EQ("400.00 kbits/s (50.00 kbytes/s)", bandwidth.ToDebugValue());
+  EXPECT_EQ("400.00 kbits/s (50.00 kbytes/s)", bandwidth.ToDebuggingValue());
 
   bandwidth = bandwidth * 1000;
-  EXPECT_EQ("400.00 Mbits/s (50.00 Mbytes/s)", bandwidth.ToDebugValue());
+  EXPECT_EQ("400.00 Mbits/s (50.00 Mbytes/s)", bandwidth.ToDebuggingValue());
 
   bandwidth = bandwidth * 1000;
-  EXPECT_EQ("400.00 Gbits/s (50.00 Gbytes/s)", bandwidth.ToDebugValue());
+  EXPECT_EQ("400.00 Gbits/s (50.00 Gbytes/s)", bandwidth.ToDebuggingValue());
 }
 
 TEST_F(QuicBandwidthTest, SpecialValues) {
diff --git a/quic/core/quic_time.cc b/quic/core/quic_time.cc
index 25cd560..ffc59da 100644
--- a/quic/core/quic_time.cc
+++ b/quic/core/quic_time.cc
@@ -13,7 +13,7 @@
 
 namespace quic {
 
-std::string QuicTime::Delta::ToDebugValue() const {
+std::string QuicTime::Delta::ToDebuggingValue() const {
   const int64_t one_ms = 1000;
   const int64_t one_s = 1000 * one_ms;
 
diff --git a/quic/core/quic_time.h b/quic/core/quic_time.h
index cd33649..9a5ae7d 100644
--- a/quic/core/quic_time.h
+++ b/quic/core/quic_time.h
@@ -75,7 +75,7 @@
       return time_offset_ == kQuicInfiniteTimeUs;
     }
 
-    std::string ToDebugValue() const;
+    std::string ToDebuggingValue() const;
 
    private:
     friend inline bool operator==(QuicTime::Delta lhs, QuicTime::Delta rhs);
@@ -275,7 +275,7 @@
 // Override stream output operator for gtest.
 inline std::ostream& operator<<(std::ostream& output,
                                 const QuicTime::Delta delta) {
-  output << delta.ToDebugValue();
+  output << delta.ToDebuggingValue();
   return output;
 }
 }  // namespace quic
diff --git a/quic/core/quic_time_test.cc b/quic/core/quic_time_test.cc
index 9720532..2e2838a 100644
--- a/quic/core/quic_time_test.cc
+++ b/quic/core/quic_time_test.cc
@@ -82,18 +82,18 @@
                QuicTime::Delta::FromSeconds(0));
 }
 
-TEST_F(QuicTimeDeltaTest, DebugValue) {
+TEST_F(QuicTimeDeltaTest, DebuggingValue) {
   const QuicTime::Delta one_us = QuicTime::Delta::FromMicroseconds(1);
   const QuicTime::Delta one_ms = QuicTime::Delta::FromMilliseconds(1);
   const QuicTime::Delta one_s = QuicTime::Delta::FromSeconds(1);
 
-  EXPECT_EQ("3s", (3 * one_s).ToDebugValue());
-  EXPECT_EQ("3ms", (3 * one_ms).ToDebugValue());
-  EXPECT_EQ("3us", (3 * one_us).ToDebugValue());
+  EXPECT_EQ("3s", (3 * one_s).ToDebuggingValue());
+  EXPECT_EQ("3ms", (3 * one_ms).ToDebuggingValue());
+  EXPECT_EQ("3us", (3 * one_us).ToDebuggingValue());
 
-  EXPECT_EQ("3001us", (3 * one_ms + one_us).ToDebugValue());
-  EXPECT_EQ("3001ms", (3 * one_s + one_ms).ToDebugValue());
-  EXPECT_EQ("3000001us", (3 * one_s + one_us).ToDebugValue());
+  EXPECT_EQ("3001us", (3 * one_ms + one_us).ToDebuggingValue());
+  EXPECT_EQ("3001ms", (3 * one_s + one_ms).ToDebuggingValue());
+  EXPECT_EQ("3000001us", (3 * one_s + one_us).ToDebuggingValue());
 }
 
 class QuicTimeTest : public QuicTest {