diff --git a/common/platform/api/quiche_command_line_flags.h b/common/platform/api/quiche_command_line_flags.h
new file mode 100644
index 0000000..3ba48bb
--- /dev/null
+++ b/common/platform/api/quiche_command_line_flags.h
@@ -0,0 +1,38 @@
+// Copyright (c) 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_COMMON_PLATFORM_API_QUICHE_COMMAND_LINE_FLAGS_H_
+#define QUICHE_COMMON_PLATFORM_API_QUICHE_COMMAND_LINE_FLAGS_H_
+
+#include <string>
+#include <vector>
+
+#include "net/quiche/common/platform/impl/quiche_command_line_flags_impl.h"
+
+// Define a command-line flag that can be automatically set via
+// QuicheParseCommandLineFlags().
+#define DEFINE_QUICHE_COMMAND_LINE_FLAG(type, name, default_value, help) \
+  DEFINE_QUICHE_COMMAND_LINE_FLAG_IMPL(type, name, default_value, help)
+
+namespace quiche {
+
+// Parses command-line flags, setting flag variables defined using
+// DEFINE_QUICHE_COMMAND_LINE_FLAG if they appear in the command line, and
+// returning a list of any non-flag arguments specified in the command line. If
+// the command line specifies '-h' or '--help', prints a usage message with flag
+// descriptions to stdout and exits with status 0. If a flag has an unparsable
+// value, writes an error message to stderr and exits with status 1.
+inline std::vector<std::string> QuicheParseCommandLineFlags(
+    const char* usage, int argc, const char* const* argv) {
+  return QuicheParseCommandLineFlagsImpl(usage, argc, argv);
+}
+
+// Prints a usage message with flag descriptions to stdout.
+inline void QuichePrintCommandLineFlagHelp(const char* usage) {
+  QuichePrintCommandLineFlagHelpImpl(usage);
+}
+
+}  // namespace quiche
+
+#endif  // QUICHE_COMMON_PLATFORM_API_QUICHE_COMMAND_LINE_FLAGS_H_
diff --git a/quic/core/congestion_control/bbr2_simulator_test.cc b/quic/core/congestion_control/bbr2_simulator_test.cc
index fbf1343..c634db5 100644
--- a/quic/core/congestion_control/bbr2_simulator_test.cc
+++ b/quic/core/congestion_control/bbr2_simulator_test.cc
@@ -29,15 +29,14 @@
 #include "quic/test_tools/simulator/simulator.h"
 #include "quic/test_tools/simulator/switch.h"
 #include "quic/test_tools/simulator/traffic_policer.h"
+#include "common/platform/api/quiche_command_line_flags.h"
 
 using testing::AllOf;
 using testing::Ge;
 using testing::Le;
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(
-    std::string,
-    quic_bbr2_test_regression_mode,
-    "",
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
+    std::string, quic_bbr2_test_regression_mode, "",
     "One of a) 'record' to record test result (one file per test), or "
     "b) 'regress' to regress against recorded results, or "
     "c) <anything else> for non-regression mode.");
diff --git a/quic/core/congestion_control/bbr_sender_test.cc b/quic/core/congestion_control/bbr_sender_test.cc
index 8973f94..caba9b1 100644
--- a/quic/core/congestion_control/bbr_sender_test.cc
+++ b/quic/core/congestion_control/bbr_sender_test.cc
@@ -28,15 +28,14 @@
 #include "quic/test_tools/simulator/quic_endpoint.h"
 #include "quic/test_tools/simulator/simulator.h"
 #include "quic/test_tools/simulator/switch.h"
+#include "common/platform/api/quiche_command_line_flags.h"
 
 using testing::AllOf;
 using testing::Ge;
 using testing::Le;
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(
-    std::string,
-    quic_bbr_test_regression_mode,
-    "",
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
+    std::string, quic_bbr_test_regression_mode, "",
     "One of a) 'record' to record test result (one file per test), or "
     "b) 'regress' to regress against recorded results, or "
     "c) <anything else> for non-regression mode.");
diff --git a/quic/core/crypto/crypto_message_printer_bin.cc b/quic/core/crypto/crypto_message_printer_bin.cc
index 68e3d9c..0159e30 100644
--- a/quic/core/crypto/crypto_message_printer_bin.cc
+++ b/quic/core/crypto/crypto_message_printer_bin.cc
@@ -13,6 +13,7 @@
 #include "absl/strings/escaping.h"
 #include "quic/core/crypto/crypto_framer.h"
 #include "quic/core/quic_utils.h"
+#include "common/platform/api/quiche_command_line_flags.h"
 
 using std::cerr;
 using std::cout;
@@ -37,9 +38,9 @@
 int main(int argc, char* argv[]) {
   const char* usage = "Usage: crypto_message_printer <hex>";
   std::vector<std::string> messages =
-      quic::QuicParseCommandLineFlags(usage, argc, argv);
+      quiche::QuicheParseCommandLineFlags(usage, argc, argv);
   if (messages.size() != 1) {
-    quic::QuicPrintCommandLineFlagHelp(usage);
+    quiche::QuichePrintCommandLineFlagHelp(usage);
     exit(0);
   }
 
diff --git a/quic/core/qpack/qpack_offline_decoder_bin.cc b/quic/core/qpack/qpack_offline_decoder_bin.cc
index 8cd1108..20f7a62 100644
--- a/quic/core/qpack/qpack_offline_decoder_bin.cc
+++ b/quic/core/qpack/qpack_offline_decoder_bin.cc
@@ -9,16 +9,17 @@
 #include "quic/platform/api/quic_flags.h"
 #include "quic/platform/api/quic_logging.h"
 #include "quic/test_tools/qpack/qpack_offline_decoder.h"
+#include "common/platform/api/quiche_command_line_flags.h"
 
 int main(int argc, char* argv[]) {
   const char* usage =
       "Usage: qpack_offline_decoder input_filename expected_headers_filename "
       "....";
   std::vector<std::string> args =
-      quic::QuicParseCommandLineFlags(usage, argc, argv);
+      quiche::QuicheParseCommandLineFlags(usage, argc, argv);
 
   if (args.size() < 2 || args.size() % 2 != 0) {
-    quic::QuicPrintCommandLineFlagHelp(usage);
+    quiche::QuichePrintCommandLineFlagHelp(usage);
     return 1;
   }
 
diff --git a/quic/masque/masque_client_bin.cc b/quic/masque/masque_client_bin.cc
index 8af288f..fb6a61d 100644
--- a/quic/masque/masque_client_bin.cc
+++ b/quic/masque/masque_client_bin.cc
@@ -23,17 +23,15 @@
 #include "quic/platform/api/quic_socket_address.h"
 #include "quic/platform/api/quic_system_event_loop.h"
 #include "quic/tools/fake_proof_verifier.h"
+#include "common/platform/api/quiche_command_line_flags.h"
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(bool,
-                              disable_certificate_verification,
-                              false,
-                              "If true, don't verify the server certificate.");
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
+    bool, disable_certificate_verification, false,
+    "If true, don't verify the server certificate.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(std::string,
-                              masque_mode,
-                              "",
-                              "Allows setting MASQUE mode, valid values are "
-                              "open and legacy. Defaults to open.");
+DEFINE_QUICHE_COMMAND_LINE_FLAG(std::string, masque_mode, "",
+                                "Allows setting MASQUE mode, valid values are "
+                                "open and legacy. Defaults to open.");
 
 namespace quic {
 
@@ -48,9 +46,10 @@
   // Note that the URI template expansion currently only supports string
   // replacement of {target_host} and {target_port}, not
   // {?target_host,target_port}.
-  std::vector<std::string> urls = QuicParseCommandLineFlags(usage, argc, argv);
+  std::vector<std::string> urls =
+      quiche::QuicheParseCommandLineFlags(usage, argc, argv);
   if (urls.empty()) {
-    QuicPrintCommandLineFlagHelp(usage);
+    quiche::QuichePrintCommandLineFlagHelp(usage);
     return 1;
   }
 
diff --git a/quic/masque/masque_server_bin.cc b/quic/masque/masque_server_bin.cc
index aaccda3..666f67f 100644
--- a/quic/masque/masque_server_bin.cc
+++ b/quic/masque/masque_server_bin.cc
@@ -15,40 +15,33 @@
 #include "quic/platform/api/quic_logging.h"
 #include "quic/platform/api/quic_socket_address.h"
 #include "quic/platform/api/quic_system_event_loop.h"
+#include "common/platform/api/quiche_command_line_flags.h"
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(int32_t,
-                              port,
-                              9661,
-                              "The port the MASQUE server will listen on.");
+DEFINE_QUICHE_COMMAND_LINE_FLAG(int32_t, port, 9661,
+                                "The port the MASQUE server will listen on.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(
-    std::string,
-    cache_dir,
-    "",
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
+    std::string, cache_dir, "",
     "Specifies the directory used during QuicHttpResponseCache "
     "construction to seed the cache. Cache directory can be "
     "generated using `wget -p --save-headers <url>`");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(
-    std::string,
-    server_authority,
-    "",
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
+    std::string, server_authority, "",
     "Specifies the authority over which the server will accept MASQUE "
     "requests. Defaults to empty which allows all authorities.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(std::string,
-                              masque_mode,
-                              "",
-                              "Allows setting MASQUE mode, valid values are "
-                              "open and legacy. Defaults to open.");
+DEFINE_QUICHE_COMMAND_LINE_FLAG(std::string, masque_mode, "",
+                                "Allows setting MASQUE mode, valid values are "
+                                "open and legacy. Defaults to open.");
 
 int main(int argc, char* argv[]) {
   QuicSystemEventLoop event_loop("masque_server");
   const char* usage = "Usage: masque_server [options]";
   std::vector<std::string> non_option_args =
-      quic::QuicParseCommandLineFlags(usage, argc, argv);
+      quiche::QuicheParseCommandLineFlags(usage, argc, argv);
   if (!non_option_args.empty()) {
-    quic::QuicPrintCommandLineFlagHelp(usage);
+    quiche::QuichePrintCommandLineFlagHelp(usage);
     return 0;
   }
 
diff --git a/quic/platform/api/quic_flags.h b/quic/platform/api/quic_flags.h
index 1a9f2d9..43f81d4 100644
--- a/quic/platform/api/quic_flags.h
+++ b/quic/platform/api/quic_flags.h
@@ -20,31 +20,4 @@
 #define GetQuicFlag(flag) GetQuicheFlag(flag)
 #define SetQuicFlag(flag, value) SetQuicheFlag(flag, value)
 
-// Define a command-line flag that can be automatically set via
-// QuicParseCommandLineFlags().
-#define DEFINE_QUIC_COMMAND_LINE_FLAG(type, name, default_value, help) \
-  DEFINE_QUIC_COMMAND_LINE_FLAG_IMPL(type, name, default_value, help)
-
-namespace quic {
-
-// Parses command-line flags, setting flag variables defined using
-// DEFINE_QUIC_COMMAND_LINE_FLAG if they appear in the command line, and
-// returning a list of any non-flag arguments specified in the command line. If
-// the command line specifies '-h' or '--help', prints a usage message with flag
-// descriptions to stdout and exits with status 0. If a flag has an unparsable
-// value, writes an error message to stderr and exits with status 1.
-inline std::vector<std::string> QuicParseCommandLineFlags(
-    const char* usage,
-    int argc,
-    const char* const* argv) {
-  return QuicParseCommandLineFlagsImpl(usage, argc, argv);
-}
-
-// Prints a usage message with flag descriptions to stdout.
-inline void QuicPrintCommandLineFlagHelp(const char* usage) {
-  QuicPrintCommandLineFlagHelpImpl(usage);
-}
-
-}  // namespace quic
-
 #endif  // QUICHE_QUIC_PLATFORM_API_QUIC_FLAGS_H_
diff --git a/quic/qbone/qbone_client_session.cc b/quic/qbone/qbone_client_session.cc
index fce08d2..87cfb2d 100644
--- a/quic/qbone/qbone_client_session.cc
+++ b/quic/qbone/qbone_client_session.cc
@@ -9,8 +9,9 @@
 #include "absl/strings/string_view.h"
 #include "quic/core/quic_types.h"
 #include "quic/qbone/qbone_constants.h"
+#include "common/platform/api/quiche_command_line_flags.h"
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
     bool, qbone_client_defer_control_stream_creation, true,
     "If true, control stream in QBONE client session is created after "
     "encryption established.");
diff --git a/quic/qbone/qbone_server_session.cc b/quic/qbone/qbone_server_session.cc
index 1fc0842..bc2d8e5 100644
--- a/quic/qbone/qbone_server_session.cc
+++ b/quic/qbone/qbone_server_session.cc
@@ -12,8 +12,9 @@
 #include "quic/core/quic_types.h"
 #include "quic/core/quic_utils.h"
 #include "quic/qbone/qbone_constants.h"
+#include "common/platform/api/quiche_command_line_flags.h"
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
     bool, qbone_server_defer_control_stream_creation, true,
     "If true, control stream in QBONE server session is created after "
     "encryption established.");
diff --git a/quic/qbone/qbone_session_base.cc b/quic/qbone/qbone_session_base.cc
index 2b3f295..702f185 100644
--- a/quic/qbone/qbone_session_base.cc
+++ b/quic/qbone/qbone_session_base.cc
@@ -18,11 +18,10 @@
 #include "quic/platform/api/quic_testvalue.h"
 #include "quic/qbone/platform/icmp_packet.h"
 #include "quic/qbone/qbone_constants.h"
+#include "common/platform/api/quiche_command_line_flags.h"
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(
-    bool,
-    qbone_close_ephemeral_frames,
-    true,
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
+    bool, qbone_close_ephemeral_frames, true,
     "If true, we'll call CloseStream even when we receive ephemeral frames.");
 
 namespace quic {
diff --git a/quic/qbone/qbone_stream.cc b/quic/qbone/qbone_stream.cc
index 5aac3e7..3901233 100644
--- a/quic/qbone/qbone_stream.cc
+++ b/quic/qbone/qbone_stream.cc
@@ -10,11 +10,10 @@
 #include "quic/core/quic_types.h"
 #include "quic/qbone/qbone_constants.h"
 #include "quic/qbone/qbone_session_base.h"
+#include "common/platform/api/quiche_command_line_flags.h"
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(int,
-                              qbone_stream_ttl_secs,
-                              3,
-                              "The QBONE Stream TTL in seconds.");
+DEFINE_QUICHE_COMMAND_LINE_FLAG(int, qbone_stream_ttl_secs, 3,
+                                "The QBONE Stream TTL in seconds.");
 
 namespace quic {
 
diff --git a/quic/tools/quic_client_bin.cc b/quic/tools/quic_client_bin.cc
index 0b98125..deedddd 100644
--- a/quic/tools/quic_client_bin.cc
+++ b/quic/tools/quic_client_bin.cc
@@ -47,6 +47,7 @@
 #include "quic/platform/api/quic_system_event_loop.h"
 #include "quic/tools/quic_epoll_client_factory.h"
 #include "quic/tools/quic_toy_client.h"
+#include "common/platform/api/quiche_command_line_flags.h"
 
 int main(int argc, char* argv[]) {
   QuicSystemEventLoop event_loop("quic_client");
@@ -54,9 +55,9 @@
 
   // All non-flag arguments should be interpreted as URLs to fetch.
   std::vector<std::string> urls =
-      quic::QuicParseCommandLineFlags(usage, argc, argv);
+      quiche::QuicheParseCommandLineFlags(usage, argc, argv);
   if (urls.size() != 1) {
-    quic::QuicPrintCommandLineFlagHelp(usage);
+    quiche::QuichePrintCommandLineFlagHelp(usage);
     exit(0);
   }
 
diff --git a/quic/tools/quic_client_interop_test_bin.cc b/quic/tools/quic_client_interop_test_bin.cc
index c90c8dd..6c14cc3 100644
--- a/quic/tools/quic_client_interop_test_bin.cc
+++ b/quic/tools/quic_client_interop_test_bin.cc
@@ -19,19 +19,16 @@
 #include "quic/tools/fake_proof_verifier.h"
 #include "quic/tools/quic_client.h"
 #include "quic/tools/quic_url.h"
+#include "common/platform/api/quiche_command_line_flags.h"
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(std::string,
-                              host,
-                              "",
-                              "The IP or hostname to connect to.");
+DEFINE_QUICHE_COMMAND_LINE_FLAG(std::string, host, "",
+                                "The IP or hostname to connect to.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(
-    std::string,
-    quic_version,
-    "",
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
+    std::string, quic_version, "",
     "The QUIC version to use. Defaults to most recent IETF QUIC version.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(int32_t, port, 0, "The port to connect to.");
+DEFINE_QUICHE_COMMAND_LINE_FLAG(int32_t, port, 0, "The port to connect to.");
 
 namespace quic {
 
@@ -403,9 +400,9 @@
   const char* usage = "Usage: quic_client_interop_test [options] [url]";
 
   std::vector<std::string> args =
-      quic::QuicParseCommandLineFlags(usage, argc, argv);
+      quiche::QuicheParseCommandLineFlags(usage, argc, argv);
   if (args.size() > 1) {
-    quic::QuicPrintCommandLineFlagHelp(usage);
+    quiche::QuichePrintCommandLineFlagHelp(usage);
     exit(1);
   }
   std::string dns_host = GetQuicFlag(FLAGS_host);
@@ -426,7 +423,7 @@
     port = 443;
   }
   if (dns_host.empty()) {
-    quic::QuicPrintCommandLineFlagHelp(usage);
+    quiche::QuichePrintCommandLineFlagHelp(usage);
     exit(1);
   }
   if (url_host.empty()) {
diff --git a/quic/tools/quic_packet_printer_bin.cc b/quic/tools/quic_packet_printer_bin.cc
index ad357e9..8ffae27 100644
--- a/quic/tools/quic_packet_printer_bin.cc
+++ b/quic/tools/quic_packet_printer_bin.cc
@@ -34,12 +34,11 @@
 #include "quic/core/quic_types.h"
 #include "quic/core/quic_utils.h"
 #include "quic/platform/api/quic_flags.h"
+#include "common/platform/api/quiche_command_line_flags.h"
 #include "common/quiche_text_utils.h"
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(std::string,
-                              quic_version,
-                              "",
-                              "If set, specify the QUIC version to use.");
+DEFINE_QUICHE_COMMAND_LINE_FLAG(std::string, quic_version, "",
+                                "If set, specify the QUIC version to use.");
 
 namespace quic {
 
@@ -248,10 +247,10 @@
 int main(int argc, char* argv[]) {
   const char* usage = "Usage: quic_packet_printer client|server <hex>";
   std::vector<std::string> args =
-      quic::QuicParseCommandLineFlags(usage, argc, argv);
+      quiche::QuicheParseCommandLineFlags(usage, argc, argv);
 
   if (args.size() < 2) {
-    quic::QuicPrintCommandLineFlagHelp(usage);
+    quiche::QuichePrintCommandLineFlagHelp(usage);
     return 1;
   }
 
@@ -263,7 +262,7 @@
     perspective = quic::Perspective::IS_SERVER;
   } else {
     std::cerr << "Invalid perspective" << std::endl;
-    quic::QuicPrintCommandLineFlagHelp(usage);
+    quiche::QuichePrintCommandLineFlagHelp(usage);
     return 1;
   }
   std::string hex = absl::HexStringToBytes(args[1]);
diff --git a/quic/tools/quic_reject_reason_decoder_bin.cc b/quic/tools/quic_reject_reason_decoder_bin.cc
index 68443f3..ed83d27 100644
--- a/quic/tools/quic_reject_reason_decoder_bin.cc
+++ b/quic/tools/quic_reject_reason_decoder_bin.cc
@@ -11,6 +11,7 @@
 #include "quic/core/crypto/crypto_handshake.h"
 #include "quic/core/crypto/crypto_utils.h"
 #include "quic/platform/api/quic_flags.h"
+#include "common/platform/api/quiche_command_line_flags.h"
 #include "common/quiche_text_utils.h"
 
 using quic::CryptoUtils;
@@ -20,7 +21,7 @@
 int main(int argc, char* argv[]) {
   const char* usage = "Usage: quic_reject_reason_decoder <packed_reason>";
   std::vector<std::string> args =
-      quic::QuicParseCommandLineFlags(usage, argc, argv);
+      quiche::QuicheParseCommandLineFlags(usage, argc, argv);
 
   if (args.size() != 1) {
     std::cerr << usage << std::endl;
diff --git a/quic/tools/quic_server_bin.cc b/quic/tools/quic_server_bin.cc
index c971367..5d3ed72 100644
--- a/quic/tools/quic_server_bin.cc
+++ b/quic/tools/quic_server_bin.cc
@@ -12,14 +12,15 @@
 #include "quic/platform/api/quic_system_event_loop.h"
 #include "quic/tools/quic_epoll_server_factory.h"
 #include "quic/tools/quic_toy_server.h"
+#include "common/platform/api/quiche_command_line_flags.h"
 
 int main(int argc, char* argv[]) {
   QuicSystemEventLoop event_loop("quic_server");
   const char* usage = "Usage: quic_server [options]";
   std::vector<std::string> non_option_args =
-      quic::QuicParseCommandLineFlags(usage, argc, argv);
+      quiche::QuicheParseCommandLineFlags(usage, argc, argv);
   if (!non_option_args.empty()) {
-    quic::QuicPrintCommandLineFlagHelp(usage);
+    quiche::QuichePrintCommandLineFlagHelp(usage);
     exit(0);
   }
 
diff --git a/quic/tools/quic_toy_client.cc b/quic/tools/quic_toy_client.cc
index 00507f3..7b6b760 100644
--- a/quic/tools/quic_toy_client.cc
+++ b/quic/tools/quic_toy_client.cc
@@ -63,6 +63,7 @@
 #include "quic/platform/api/quic_system_event_loop.h"
 #include "quic/tools/fake_proof_verifier.h"
 #include "quic/tools/quic_url.h"
+#include "common/platform/api/quiche_command_line_flags.h"
 #include "common/quiche_text_utils.h"
 
 namespace {
@@ -71,162 +72,120 @@
 
 }  // namespace
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(
-    std::string,
-    host,
-    "",
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
+    std::string, host, "",
     "The IP or hostname to connect to. If not provided, the host "
     "will be derived from the provided URL.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(int32_t, port, 0, "The port to connect to.");
+DEFINE_QUICHE_COMMAND_LINE_FLAG(int32_t, port, 0, "The port to connect to.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(std::string,
-                              ip_version_for_host_lookup,
-                              "",
-                              "Only used if host address lookup is needed. "
-                              "4=ipv4; 6=ipv6; otherwise=don't care.");
+DEFINE_QUICHE_COMMAND_LINE_FLAG(std::string, ip_version_for_host_lookup, "",
+                                "Only used if host address lookup is needed. "
+                                "4=ipv4; 6=ipv6; otherwise=don't care.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(std::string,
-                              body,
-                              "",
-                              "If set, send a POST with this body.");
+DEFINE_QUICHE_COMMAND_LINE_FLAG(std::string, body, "",
+                                "If set, send a POST with this body.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(
-    std::string,
-    body_hex,
-    "",
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
+    std::string, body_hex, "",
     "If set, contents are converted from hex to ascii, before "
     "sending as body of a POST. e.g. --body_hex=\"68656c6c6f\"");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(
-    std::string,
-    headers,
-    "",
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
+    std::string, headers, "",
     "A semicolon separated list of key:value pairs to "
     "add to request headers.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(bool,
-                              quiet,
-                              false,
-                              "Set to true for a quieter output experience.");
+DEFINE_QUICHE_COMMAND_LINE_FLAG(bool, quiet, false,
+                                "Set to true for a quieter output experience.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(
-    std::string,
-    quic_version,
-    "",
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
+    std::string, quic_version, "",
     "QUIC version to speak, e.g. 21. If not set, then all available "
     "versions are offered in the handshake. Also supports wire versions "
     "such as Q043 or T099.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(
-    std::string,
-    connection_options,
-    "",
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
+    std::string, connection_options, "",
     "Connection options as ASCII tags separated by commas, "
     "e.g. \"ABCD,EFGH\"");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(
-    std::string,
-    client_connection_options,
-    "",
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
+    std::string, client_connection_options, "",
     "Client connection options as ASCII tags separated by commas, "
     "e.g. \"ABCD,EFGH\"");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(bool,
-                              quic_ietf_draft,
-                              false,
-                              "Use the IETF draft version. This also enables "
-                              "required internal QUIC flags.");
+DEFINE_QUICHE_COMMAND_LINE_FLAG(bool, quic_ietf_draft, false,
+                                "Use the IETF draft version. This also enables "
+                                "required internal QUIC flags.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(
-    bool,
-    version_mismatch_ok,
-    false,
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
+    bool, version_mismatch_ok, false,
     "If true, a version mismatch in the handshake is not considered a "
     "failure. Useful for probing a server to determine if it speaks "
     "any version of QUIC.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(
-    bool,
-    force_version_negotiation,
-    false,
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
+    bool, force_version_negotiation, false,
     "If true, start by proposing a version that is reserved for version "
     "negotiation.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(
-    bool,
-    multi_packet_chlo,
-    false,
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
+    bool, multi_packet_chlo, false,
     "If true, add a transport parameter to make the ClientHello span two "
     "packets. Only works with QUIC+TLS.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(
-    bool,
-    redirect_is_success,
-    true,
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
+    bool, redirect_is_success, true,
     "If true, an HTTP response code of 3xx is considered to be a "
     "successful response, otherwise a failure.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(int32_t,
-                              initial_mtu,
-                              0,
-                              "Initial MTU of the connection.");
+DEFINE_QUICHE_COMMAND_LINE_FLAG(int32_t, initial_mtu, 0,
+                                "Initial MTU of the connection.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(
-    int32_t,
-    num_requests,
-    1,
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
+    int32_t, num_requests, 1,
     "How many sequential requests to make on a single connection.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(bool,
-                              disable_certificate_verification,
-                              false,
-                              "If true, don't verify the server certificate.");
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
+    bool, disable_certificate_verification, false,
+    "If true, don't verify the server certificate.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
     std::string, default_client_cert, "",
     "The path to the file containing PEM-encoded client default certificate to "
     "be sent to the server, if server requested client certs.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
     std::string, default_client_cert_key, "",
     "The path to the file containing PEM-encoded private key of the client's "
     "default certificate for signing, if server requested client certs.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(
-    bool,
-    drop_response_body,
-    false,
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
+    bool, drop_response_body, false,
     "If true, drop response body immediately after it is received.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(
-    bool,
-    disable_port_changes,
-    false,
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
+    bool, disable_port_changes, false,
     "If true, do not change local port after each request.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(bool,
-                              one_connection_per_request,
-                              false,
-                              "If true, close the connection after each "
-                              "request. This allows testing 0-RTT.");
+DEFINE_QUICHE_COMMAND_LINE_FLAG(bool, one_connection_per_request, false,
+                                "If true, close the connection after each "
+                                "request. This allows testing 0-RTT.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(int32_t,
-                              server_connection_id_length,
-                              -1,
-                              "Length of the server connection ID used.");
+DEFINE_QUICHE_COMMAND_LINE_FLAG(int32_t, server_connection_id_length, -1,
+                                "Length of the server connection ID used.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(int32_t,
-                              client_connection_id_length,
-                              -1,
-                              "Length of the client connection ID used.");
+DEFINE_QUICHE_COMMAND_LINE_FLAG(int32_t, client_connection_id_length, -1,
+                                "Length of the client connection ID used.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(int32_t, max_time_before_crypto_handshake_ms,
-                              10000,
-                              "Max time to wait before handshake completes.");
+DEFINE_QUICHE_COMMAND_LINE_FLAG(int32_t, max_time_before_crypto_handshake_ms,
+                                10000,
+                                "Max time to wait before handshake completes.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(int32_t, max_inbound_header_list_size, 128 * 1024,
-                              "Max inbound header list size. 0 means default.");
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
+    int32_t, max_inbound_header_list_size, 128 * 1024,
+    "Max inbound header list size. 0 means default.");
 
 namespace quic {
 namespace {
diff --git a/quic/tools/quic_toy_server.cc b/quic/tools/quic_toy_server.cc
index e7b4e1e..cdbe9b3 100644
--- a/quic/tools/quic_toy_server.cc
+++ b/quic/tools/quic_toy_server.cc
@@ -12,44 +12,33 @@
 #include "quic/platform/api/quic_flags.h"
 #include "quic/platform/api/quic_socket_address.h"
 #include "quic/tools/quic_memory_cache_backend.h"
+#include "common/platform/api/quiche_command_line_flags.h"
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(int32_t,
-                              port,
-                              6121,
-                              "The port the quic server will listen on.");
+DEFINE_QUICHE_COMMAND_LINE_FLAG(int32_t, port, 6121,
+                                "The port the quic server will listen on.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(
-    std::string,
-    quic_response_cache_dir,
-    "",
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
+    std::string, quic_response_cache_dir, "",
     "Specifies the directory used during QuicHttpResponseCache "
     "construction to seed the cache. Cache directory can be "
     "generated using `wget -p --save-headers <url>`");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(
-    bool,
-    generate_dynamic_responses,
-    false,
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
+    bool, generate_dynamic_responses, false,
     "If true, then URLs which have a numeric path will send a dynamically "
     "generated response of that many bytes.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(bool,
-                              quic_ietf_draft,
-                              false,
-                              "Only enable IETF draft versions. This also "
-                              "enables required internal QUIC flags.");
+DEFINE_QUICHE_COMMAND_LINE_FLAG(bool, quic_ietf_draft, false,
+                                "Only enable IETF draft versions. This also "
+                                "enables required internal QUIC flags.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(
-    std::string,
-    quic_versions,
-    "",
+DEFINE_QUICHE_COMMAND_LINE_FLAG(
+    std::string, quic_versions, "",
     "QUIC versions to enable, e.g. \"h3-25,h3-27\". If not set, then all "
     "available versions are enabled.");
 
-DEFINE_QUIC_COMMAND_LINE_FLAG(bool,
-                              enable_webtransport,
-                              false,
-                              "If true, WebTransport support is enabled.");
+DEFINE_QUICHE_COMMAND_LINE_FLAG(bool, enable_webtransport, false,
+                                "If true, WebTransport support is enabled.");
 
 namespace quic {