diff --git a/common/platform/api/quiche_text_utils.h b/common/platform/api/quiche_text_utils.h
index 4de3647..5bc5f50 100644
--- a/common/platform/api/quiche_text_utils.h
+++ b/common/platform/api/quiche_text_utils.h
@@ -27,30 +27,6 @@
     quiche::QuicheTextUtilsImpl::RemoveLeadingAndTrailingWhitespace(data);
   }
 
-  // Returns true if |in| represents a valid uint64, and stores that value in
-  // |out|.
-  static bool StringToUint64(absl::string_view in, uint64_t* out) {
-    return quiche::QuicheTextUtilsImpl::StringToUint64(in, out);
-  }
-
-  // Returns true if |in| represents a valid int, and stores that value in
-  // |out|.
-  static bool StringToInt(absl::string_view in, int* out) {
-    return quiche::QuicheTextUtilsImpl::StringToInt(in, out);
-  }
-
-  // Returns true if |in| represents a valid uint32, and stores that value in
-  // |out|.
-  static bool StringToUint32(absl::string_view in, uint32_t* out) {
-    return quiche::QuicheTextUtilsImpl::StringToUint32(in, out);
-  }
-
-  // Returns true if |in| represents a valid size_t, and stores that value in
-  // |out|.
-  static bool StringToSizeT(absl::string_view in, size_t* out) {
-    return quiche::QuicheTextUtilsImpl::StringToSizeT(in, out);
-  }
-
   // Returns a new string representing |in|.
   static std::string Uint64ToString(uint64_t in) {
     return quiche::QuicheTextUtilsImpl::Uint64ToString(in);
diff --git a/common/platform/api/quiche_text_utils_test.cc b/common/platform/api/quiche_text_utils_test.cc
index bbea2cd..012d33d 100644
--- a/common/platform/api/quiche_text_utils_test.cc
+++ b/common/platform/api/quiche_text_utils_test.cc
@@ -32,89 +32,6 @@
   }
 }
 
-TEST_F(QuicheTextUtilsTest, StringToNumbers) {
-  const std::string kMaxInt32Plus1 = "2147483648";
-  const std::string kMinInt32Minus1 = "-2147483649";
-  const std::string kMaxUint32Plus1 = "4294967296";
-
-  {
-    // StringToUint64
-    uint64_t uint64_val = 0;
-    EXPECT_TRUE(quiche::QuicheTextUtils::StringToUint64("123", &uint64_val));
-    EXPECT_EQ(123u, uint64_val);
-    EXPECT_TRUE(quiche::QuicheTextUtils::StringToUint64("1234", &uint64_val));
-    EXPECT_EQ(1234u, uint64_val);
-    EXPECT_FALSE(quiche::QuicheTextUtils::StringToUint64("", &uint64_val));
-    EXPECT_FALSE(quiche::QuicheTextUtils::StringToUint64("-123", &uint64_val));
-    EXPECT_FALSE(
-        quiche::QuicheTextUtils::StringToUint64("-123.0", &uint64_val));
-    EXPECT_TRUE(
-        quiche::QuicheTextUtils::StringToUint64(kMaxUint32Plus1, &uint64_val));
-    EXPECT_EQ(4294967296u, uint64_val);
-  }
-
-  {
-    // StringToint
-    int int_val = 0;
-    EXPECT_TRUE(quiche::QuicheTextUtils::StringToInt("123", &int_val));
-    EXPECT_EQ(123, int_val);
-    EXPECT_TRUE(quiche::QuicheTextUtils::StringToInt("1234", &int_val));
-    EXPECT_EQ(1234, int_val);
-    EXPECT_FALSE(quiche::QuicheTextUtils::StringToInt("", &int_val));
-    EXPECT_TRUE(quiche::QuicheTextUtils::StringToInt("-123", &int_val));
-    EXPECT_EQ(-123, int_val);
-    EXPECT_FALSE(quiche::QuicheTextUtils::StringToInt("-123.0", &int_val));
-    if (sizeof(int) > 4) {
-      EXPECT_TRUE(
-          quiche::QuicheTextUtils::StringToInt(kMinInt32Minus1, &int_val));
-      EXPECT_EQ(-2147483649ll, int_val);
-      EXPECT_TRUE(
-          quiche::QuicheTextUtils::StringToInt(kMaxInt32Plus1, &int_val));
-      EXPECT_EQ(2147483648ll, int_val);
-    } else {
-      EXPECT_FALSE(
-          quiche::QuicheTextUtils::StringToInt(kMinInt32Minus1, &int_val));
-      EXPECT_FALSE(
-          quiche::QuicheTextUtils::StringToInt(kMaxInt32Plus1, &int_val));
-    }
-  }
-
-  {
-    // StringToUint32
-    uint32_t uint32_val = 0;
-    EXPECT_TRUE(quiche::QuicheTextUtils::StringToUint32("123", &uint32_val));
-    EXPECT_EQ(123u, uint32_val);
-    EXPECT_TRUE(quiche::QuicheTextUtils::StringToUint32("1234", &uint32_val));
-    EXPECT_EQ(1234u, uint32_val);
-    EXPECT_FALSE(quiche::QuicheTextUtils::StringToUint32("", &uint32_val));
-    EXPECT_FALSE(quiche::QuicheTextUtils::StringToUint32("-123", &uint32_val));
-    EXPECT_FALSE(
-        quiche::QuicheTextUtils::StringToUint32("-123.0", &uint32_val));
-    EXPECT_FALSE(
-        quiche::QuicheTextUtils::StringToUint32(kMaxUint32Plus1, &uint32_val));
-  }
-
-  {
-    // StringToSizeT
-    size_t size_t_val = 0;
-    EXPECT_TRUE(quiche::QuicheTextUtils::StringToSizeT("123", &size_t_val));
-    EXPECT_EQ(123u, size_t_val);
-    EXPECT_TRUE(quiche::QuicheTextUtils::StringToSizeT("1234", &size_t_val));
-    EXPECT_EQ(1234u, size_t_val);
-    EXPECT_FALSE(quiche::QuicheTextUtils::StringToSizeT("", &size_t_val));
-    EXPECT_FALSE(quiche::QuicheTextUtils::StringToSizeT("-123", &size_t_val));
-    EXPECT_FALSE(quiche::QuicheTextUtils::StringToSizeT("-123.0", &size_t_val));
-    if (sizeof(size_t) > 4) {
-      EXPECT_TRUE(
-          quiche::QuicheTextUtils::StringToSizeT(kMaxUint32Plus1, &size_t_val));
-      EXPECT_EQ(4294967296ull, size_t_val);
-    } else {
-      EXPECT_FALSE(
-          quiche::QuicheTextUtils::StringToSizeT(kMaxUint32Plus1, &size_t_val));
-    }
-  }
-}
-
 TEST_F(QuicheTextUtilsTest, Uint64ToString) {
   EXPECT_EQ("123", quiche::QuicheTextUtils::Uint64ToString(123));
   EXPECT_EQ("1234", quiche::QuicheTextUtils::Uint64ToString(1234));
diff --git a/common/quiche_data_reader.cc b/common/quiche_data_reader.cc
index 395d5c0..bbb4b87 100644
--- a/common/quiche_data_reader.cc
+++ b/common/quiche_data_reader.cc
@@ -6,6 +6,7 @@
 
 #include <cstring>
 
+#include "absl/strings/numbers.h"
 #include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_logging.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
@@ -125,7 +126,7 @@
     return false;
   }
 
-  return QuicheTextUtils::StringToUint64(digits, result);
+  return absl::SimpleAtoi(digits, result);
 }
 
 absl::string_view QuicheDataReader::ReadRemainingPayload() {
diff --git a/quic/core/http/quic_receive_control_stream.cc b/quic/core/http/quic_receive_control_stream.cc
index 493ad0d..744e2ec 100644
--- a/quic/core/http/quic_receive_control_stream.cc
+++ b/quic/core/http/quic_receive_control_stream.cc
@@ -6,6 +6,7 @@
 
 #include <utility>
 
+#include "absl/strings/numbers.h"
 #include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/http/http_constants.h"
 #include "net/third_party/quiche/src/quic/core/http/http_decoder.h"
@@ -229,8 +230,7 @@
 
     absl::string_view value = key_and_value[1];
     int urgency;
-    if (!quiche::QuicheTextUtils::StringToInt(value, &urgency) || urgency < 0 ||
-        urgency > 7) {
+    if (!absl::SimpleAtoi(value, &urgency) || urgency < 0 || urgency > 7) {
       stream_delegate()->OnStreamError(
           QUIC_INVALID_STREAM_ID,
           "Invalid value for PRIORITY_UPDATE urgency parameter.");
diff --git a/quic/core/http/quic_spdy_session.cc b/quic/core/http/quic_spdy_session.cc
index 8658f8e..eb7228b 100644
--- a/quic/core/http/quic_spdy_session.cc
+++ b/quic/core/http/quic_spdy_session.cc
@@ -11,6 +11,7 @@
 #include <utility>
 
 #include "absl/base/attributes.h"
+#include "absl/strings/numbers.h"
 #include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/http/http_constants.h"
 #include "net/third_party/quiche/src/quic/core/http/quic_headers_stream.h"
@@ -524,8 +525,7 @@
       const std::string& header_key = header.first;
       const std::string& header_value = header.second;
       if (header_key == kFinalOffsetHeaderKey) {
-        if (!quiche::QuicheTextUtils::StringToSizeT(header_value,
-                                                    &final_byte_offset)) {
+        if (!absl::SimpleAtoi(header_value, &final_byte_offset)) {
           connection()->CloseConnection(
               QUIC_INVALID_HEADERS_STREAM_DATA,
               "Trailers are malformed (no final offset)",
diff --git a/quic/core/http/quic_spdy_stream.cc b/quic/core/http/quic_spdy_stream.cc
index f069bad..c58bb03 100644
--- a/quic/core/http/quic_spdy_stream.cc
+++ b/quic/core/http/quic_spdy_stream.cc
@@ -9,6 +9,7 @@
 #include <utility>
 
 #include "absl/base/macros.h"
+#include "absl/strings/numbers.h"
 #include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/http/http_constants.h"
 #include "net/third_party/quiche/src/quic/core/http/http_decoder.h"
@@ -844,7 +845,7 @@
   if (!isdigit(status[1]) || !isdigit(status[2])) {
     return false;
   }
-  return quiche::QuicheTextUtils::StringToInt(status, status_code);
+  return absl::SimpleAtoi(status, status_code);
 }
 
 bool QuicSpdyStream::FinishedReadingTrailers() const {
diff --git a/quic/core/http/spdy_utils.cc b/quic/core/http/spdy_utils.cc
index 87025e4..0eb05a8 100644
--- a/quic/core/http/spdy_utils.cc
+++ b/quic/core/http/spdy_utils.cc
@@ -8,6 +8,7 @@
 #include <string>
 #include <vector>
 
+#include "absl/strings/numbers.h"
 #include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_flag_utils.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
@@ -34,7 +35,7 @@
         quiche::QuicheTextUtils::Split(content_length_header, '\0');
     for (const absl::string_view& value : values) {
       uint64_t new_value;
-      if (!quiche::QuicheTextUtils::StringToUint64(value, &new_value) ||
+      if (!absl::SimpleAtoi(value, &new_value) ||
           !quiche::QuicheTextUtils::IsAllDigits(value)) {
         QUIC_DLOG(ERROR)
             << "Content length was either unparseable or negative.";
@@ -96,7 +97,7 @@
     // response body bytes expected.
     if (expect_final_byte_offset && !found_final_byte_offset &&
         name == kFinalOffsetHeaderKey &&
-        quiche::QuicheTextUtils::StringToSizeT(p.second, final_byte_offset)) {
+        absl::SimpleAtoi(p.second, final_byte_offset)) {
       found_final_byte_offset = true;
       continue;
     }
diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc
index 155e76d..66765b0 100644
--- a/quic/core/quic_framer.cc
+++ b/quic/core/quic_framer.cc
@@ -14,6 +14,7 @@
 #include "absl/base/attributes.h"
 #include "absl/base/macros.h"
 #include "absl/base/optimization.h"
+#include "absl/strings/numbers.h"
 #include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_framer.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake.h"
@@ -6846,7 +6847,7 @@
       quiche::QuicheTextUtils::Split(frame->error_details, ':');
   uint64_t extracted_error_code;
   if (ed.size() < 2 || !quiche::QuicheTextUtils::IsAllDigits(ed[0]) ||
-      !quiche::QuicheTextUtils::StringToUint64(ed[0], &extracted_error_code)) {
+      !absl::SimpleAtoi(ed[0], &extracted_error_code)) {
     if (frame->close_type == IETF_QUIC_TRANSPORT_CONNECTION_CLOSE &&
         frame->wire_error_code == NO_IETF_QUIC_ERROR) {
       frame->quic_error_code = QUIC_NO_ERROR;
diff --git a/quic/core/quic_versions.cc b/quic/core/quic_versions.cc
index 98bef7f..4c5571f 100644
--- a/quic/core/quic_versions.cc
+++ b/quic/core/quic_versions.cc
@@ -7,6 +7,7 @@
 #include <string>
 
 #include "absl/base/macros.h"
+#include "absl/strings/numbers.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_random.h"
 #include "net/third_party/quiche/src/quic/core/quic_tag.h"
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
@@ -333,8 +334,7 @@
     return UnsupportedQuicVersion();
   }
   int quic_version_number = 0;
-  if (quiche::QuicheTextUtils::StringToInt(version_string,
-                                           &quic_version_number) &&
+  if (absl::SimpleAtoi(version_string, &quic_version_number) &&
       quic_version_number > 0) {
     QuicTransportVersion transport_version =
         static_cast<QuicTransportVersion>(quic_version_number);
diff --git a/quic/test_tools/qpack/qpack_offline_decoder.cc b/quic/test_tools/qpack/qpack_offline_decoder.cc
index 211417f..38cd8fb 100644
--- a/quic/test_tools/qpack/qpack_offline_decoder.cc
+++ b/quic/test_tools/qpack/qpack_offline_decoder.cc
@@ -31,6 +31,7 @@
 #include <utility>
 
 #include "absl/strings/match.h"
+#include "absl/strings/numbers.h"
 #include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_file_utils.h"
@@ -102,8 +103,7 @@
 
   // Maximum allowed number of blocked streams.
   uint64_t max_blocked_streams = 0;
-  if (!quiche::QuicheTextUtils::StringToUint64(*piece_it,
-                                               &max_blocked_streams)) {
+  if (!absl::SimpleAtoi(*piece_it, &max_blocked_streams)) {
     QUIC_LOG(ERROR) << "Error parsing part of input filename \"" << *piece_it
                     << "\" as an integer.";
     return false;
@@ -113,8 +113,7 @@
 
   // Maximum Dynamic Table Capacity in bytes
   uint64_t maximum_dynamic_table_capacity = 0;
-  if (!quiche::QuicheTextUtils::StringToUint64(
-          *piece_it, &maximum_dynamic_table_capacity)) {
+  if (!absl::SimpleAtoi(*piece_it, &maximum_dynamic_table_capacity)) {
     QUIC_LOG(ERROR) << "Error parsing part of input filename \"" << *piece_it
                     << "\" as an integer.";
     return false;
diff --git a/quic/tools/quic_memory_cache_backend.cc b/quic/tools/quic_memory_cache_backend.cc
index 84596fd..f6ecadd 100644
--- a/quic/tools/quic_memory_cache_backend.cc
+++ b/quic/tools/quic_memory_cache_backend.cc
@@ -7,6 +7,7 @@
 #include <utility>
 
 #include "absl/strings/match.h"
+#include "absl/strings/numbers.h"
 #include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/http/spdy_utils.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
@@ -145,8 +146,8 @@
   if (it == responses_.end()) {
     uint64_t ignored = 0;
     if (generate_bytes_response_) {
-      if (quiche::QuicheTextUtils::StringToUint64(
-              absl::string_view(path.data() + 1, path.size() - 1), &ignored)) {
+      if (absl::SimpleAtoi(absl::string_view(path.data() + 1, path.size() - 1),
+                           &ignored)) {
         // The actual parsed length is ignored here and will be recomputed
         // by the caller.
         return generate_bytes_response_.get();
diff --git a/quic/tools/quic_reject_reason_decoder_bin.cc b/quic/tools/quic_reject_reason_decoder_bin.cc
index f7e3b75..f17cd03 100644
--- a/quic/tools/quic_reject_reason_decoder_bin.cc
+++ b/quic/tools/quic_reject_reason_decoder_bin.cc
@@ -7,6 +7,7 @@
 
 #include <iostream>
 
+#include "absl/strings/numbers.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_utils.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
@@ -27,7 +28,7 @@
   }
 
   uint32_t packed_error = 0;
-  if (!quiche::QuicheTextUtils::StringToUint32(args[0], &packed_error)) {
+  if (!absl::SimpleAtoi(args[0], &packed_error)) {
     std::cerr << "Unable to parse: " << args[0] << "\n";
     return 2;
   }
diff --git a/quic/tools/quic_simple_server_stream.cc b/quic/tools/quic_simple_server_stream.cc
index bbae2bc..93b4356 100644
--- a/quic/tools/quic_simple_server_stream.cc
+++ b/quic/tools/quic_simple_server_stream.cc
@@ -7,6 +7,7 @@
 #include <list>
 #include <utility>
 
+#include "absl/strings/numbers.h"
 #include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/http/quic_spdy_stream.h"
 #include "net/third_party/quiche/src/quic/core/http/spdy_utils.h"
@@ -257,8 +258,7 @@
   if (response->response_type() == QuicBackendResponse::GENERATE_BYTES) {
     QUIC_DVLOG(1) << "Stream " << id() << " sending a generate bytes response.";
     std::string path = request_headers_[":path"].as_string().substr(1);
-    if (!quiche::QuicheTextUtils::StringToUint64(path,
-                                                 &generate_bytes_length_)) {
+    if (!absl::SimpleAtoi(path, &generate_bytes_length_)) {
       QUIC_LOG(ERROR) << "Path is not a number.";
       SendNotFoundResponse();
       return;
diff --git a/quic/tools/quic_spdy_client_base.cc b/quic/tools/quic_spdy_client_base.cc
index e96b19c..134e673 100644
--- a/quic/tools/quic_spdy_client_base.cc
+++ b/quic/tools/quic_spdy_client_base.cc
@@ -6,6 +6,7 @@
 
 #include <utility>
 
+#include "absl/strings/numbers.h"
 #include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_random.h"
 #include "net/third_party/quiche/src/quic/core/http/spdy_utils.h"
@@ -91,8 +92,7 @@
     auto status = response_headers.find(":status");
     if (status == response_headers.end()) {
       QUIC_LOG(ERROR) << "Missing :status response header";
-    } else if (!quiche::QuicheTextUtils::StringToInt(status->second,
-                                                     &latest_response_code_)) {
+    } else if (!absl::SimpleAtoi(status->second, &latest_response_code_)) {
       QUIC_LOG(ERROR) << "Invalid :status response header: " << status->second;
     }
     latest_response_headers_ = response_headers.DebugString();