diff --git a/quic/tools/quic_backend_response.cc b/quic/tools/quic_backend_response.cc
index 4ef00a0..7900683 100644
--- a/quic/tools/quic_backend_response.cc
+++ b/quic/tools/quic_backend_response.cc
@@ -10,7 +10,7 @@
     QuicUrl request_url,
     spdy::SpdyHeaderBlock headers,
     spdy::SpdyPriority priority,
-    QuicString body)
+    std::string body)
     : request_url(request_url),
       headers(std::move(headers)),
       priority(priority),
diff --git a/quic/tools/quic_backend_response.h b/quic/tools/quic_backend_response.h
index cd052c8..4ef0fdc 100644
--- a/quic/tools/quic_backend_response.h
+++ b/quic/tools/quic_backend_response.h
@@ -20,13 +20,13 @@
     ServerPushInfo(QuicUrl request_url,
                    spdy::SpdyHeaderBlock headers,
                    spdy::SpdyPriority priority,
-                   QuicString body);
+                   std::string body);
     ServerPushInfo(const ServerPushInfo& other);
 
     QuicUrl request_url;
     spdy::SpdyHeaderBlock headers;
     spdy::SpdyPriority priority;
-    QuicString body;
+    std::string body;
   };
 
   enum SpecialResponseType {
@@ -75,7 +75,7 @@
   SpecialResponseType response_type_;
   spdy::SpdyHeaderBlock headers_;
   spdy::SpdyHeaderBlock trailers_;
-  QuicString body_;
+  std::string body_;
   uint16_t stop_sending_code_;
 };
 
diff --git a/quic/tools/quic_client_base.h b/quic/tools/quic_client_base.h
index 3b09e18..261fc2b 100644
--- a/quic/tools/quic_client_base.h
+++ b/quic/tools/quic_client_base.h
@@ -127,7 +127,7 @@
   // This should only be set before the initial Connect()
   void set_server_id(const QuicServerId& server_id) { server_id_ = server_id; }
 
-  void SetUserAgentID(const QuicString& user_agent_id) {
+  void SetUserAgentID(const std::string& user_agent_id) {
     crypto_config_.set_user_agent_id(user_agent_id);
   }
 
diff --git a/quic/tools/quic_client_bin.cc b/quic/tools/quic_client_bin.cc
index 1083f0d..412fb8e 100644
--- a/quic/tools/quic_client_bin.cc
+++ b/quic/tools/quic_client_bin.cc
@@ -60,7 +60,6 @@
 namespace {
 
 using quic::QuicSocketAddress;
-using quic::QuicString;
 using quic::QuicStringPiece;
 using quic::QuicTextUtils;
 using quic::QuicUrl;
@@ -97,7 +96,7 @@
   }
 };
 
-QuicSocketAddress LookupAddress(QuicString host, QuicString port) {
+QuicSocketAddress LookupAddress(std::string host, std::string port) {
   addrinfo hint;
   memset(&hint, 0, sizeof(hint));
   hint.ai_protocol = IPPROTO_UDP;
@@ -200,7 +199,7 @@
   const char* usage = "Usage: quic_client [options] <url>";
 
   // All non-flag arguments should be interpreted as URLs to fetch.
-  std::vector<QuicString> urls =
+  std::vector<std::string> urls =
       quic::QuicParseCommandLineFlags(usage, argc, argv);
   if (urls.size() != 1) {
     quic::QuicPrintCommandLineFlagHelp(usage);
diff --git a/quic/tools/quic_client_epoll_network_helper.cc b/quic/tools/quic_client_epoll_network_helper.cc
index 846911f..e545ee2 100644
--- a/quic/tools/quic_client_epoll_network_helper.cc
+++ b/quic/tools/quic_client_epoll_network_helper.cc
@@ -55,7 +55,7 @@
   CleanUpAllUDPSockets();
 }
 
-QuicString QuicClientEpollNetworkHelper::Name() const {
+std::string QuicClientEpollNetworkHelper::Name() const {
   return "QuicClientEpollNetworkHelper";
 }
 
diff --git a/quic/tools/quic_client_epoll_network_helper.h b/quic/tools/quic_client_epoll_network_helper.h
index e0f8cf3..d66dbb1 100644
--- a/quic/tools/quic_client_epoll_network_helper.h
+++ b/quic/tools/quic_client_epoll_network_helper.h
@@ -44,7 +44,7 @@
   ~QuicClientEpollNetworkHelper() override;
 
   // Return a name describing the class for use in debug/error reporting.
-  QuicString Name() const override;
+  std::string Name() const override;
 
   // From EpollCallbackInterface
   void OnRegistration(QuicEpollServer* eps, int fd, int event_mask) override;
diff --git a/quic/tools/quic_client_test.cc b/quic/tools/quic_client_test.cc
index 7977f05..12a687c 100644
--- a/quic/tools/quic_client_test.cc
+++ b/quic/tools/quic_client_test.cc
@@ -24,8 +24,8 @@
 
 const char* kPathToFds = "/proc/self/fd";
 
-QuicString ReadLink(const QuicString& path) {
-  QuicString result(PATH_MAX, '\0');
+std::string ReadLink(const std::string& path) {
+  std::string result(PATH_MAX, '\0');
   ssize_t result_size = readlink(path.c_str(), &result[0], result.size());
   CHECK(result_size > 0 && static_cast<size_t>(result_size) < result.size());
   result.resize(result_size);
@@ -44,7 +44,7 @@
       continue;
     }
 
-    QuicString fd_path = ReadLink(QuicStrCat(kPathToFds, "/", name));
+    std::string fd_path = ReadLink(QuicStrCat(kPathToFds, "/", name));
     if (QuicTextUtils::StartsWith(fd_path, "socket:")) {
       socket_count++;
     }
diff --git a/quic/tools/quic_memory_cache_backend.cc b/quic/tools/quic_memory_cache_backend.cc
index 9f333dd..76a52c3 100644
--- a/quic/tools/quic_memory_cache_backend.cc
+++ b/quic/tools/quic_memory_cache_backend.cc
@@ -19,7 +19,7 @@
 
 namespace quic {
 
-QuicMemoryCacheBackend::ResourceFile::ResourceFile(const QuicString& file_name)
+QuicMemoryCacheBackend::ResourceFile::ResourceFile(const std::string& file_name)
     : file_name_(file_name) {}
 
 QuicMemoryCacheBackend::ResourceFile::~ResourceFile() = default;
@@ -31,7 +31,7 @@
   size_t start = 0;
   while (start < file_contents_.length()) {
     size_t pos = file_contents_.find("\n", start);
-    if (pos == QuicString::npos) {
+    if (pos == std::string::npos) {
       QUIC_LOG(DFATAL) << "Headers invalid or empty, ignoring: " << file_name_;
       return;
     }
@@ -49,7 +49,7 @@
     // Extract the status from the HTTP first line.
     if (line.substr(0, 4) == "HTTP") {
       pos = line.find(" ");
-      if (pos == QuicString::npos) {
+      if (pos == std::string::npos) {
         QUIC_LOG(DFATAL) << "Headers invalid or empty, ignoring: "
                          << file_name_;
         return;
@@ -59,7 +59,7 @@
     }
     // Headers are "key: value".
     pos = line.find(": ");
-    if (pos == QuicString::npos) {
+    if (pos == std::string::npos) {
       QUIC_LOG(DFATAL) << "Headers invalid or empty, ignoring: " << file_name_;
       return;
     }
@@ -86,7 +86,7 @@
     size_t start = 0;
     while (start < push_urls.length()) {
       size_t pos = push_urls.find('\0', start);
-      if (pos == QuicString::npos) {
+      if (pos == std::string::npos) {
         push_urls_.push_back(QuicStringPiece(push_urls.data() + start,
                                              push_urls.length() - start));
         break;
@@ -227,7 +227,7 @@
 QuicMemoryCacheBackend::QuicMemoryCacheBackend() : cache_initialized_(false) {}
 
 bool QuicMemoryCacheBackend::InitializeBackend(
-    const QuicString& cache_directory) {
+    const std::string& cache_directory) {
   if (cache_directory.empty()) {
     QUIC_BUG << "cache_directory must not be empty.";
     return false;
@@ -235,7 +235,7 @@
   QUIC_LOG(INFO)
       << "Attempting to initialize QuicMemoryCacheBackend from directory: "
       << cache_directory;
-  std::vector<QuicString> files = ReadFileContents(cache_directory);
+  std::vector<std::string> files = ReadFileContents(cache_directory);
   std::list<std::unique_ptr<ResourceFile>> resource_files;
   for (const auto& filename : files) {
     std::unique_ptr<ResourceFile> resource_file(new ResourceFile(filename));
@@ -267,7 +267,7 @@
       }
       push_resources.push_back(ServerPushInfo(url, response->headers().Clone(),
                                               kV3LowestPriority,
-                                              (QuicString(response->body()))));
+                                              (std::string(response->body()))));
     }
     MaybeAddServerPushResources(resource_file->host(), resource_file->path(),
                                 push_resources);
@@ -282,7 +282,7 @@
 
 void QuicMemoryCacheBackend::FetchResponseFromBackend(
     const SpdyHeaderBlock& request_headers,
-    const QuicString& request_body,
+    const std::string& request_body,
     QuicSimpleServerBackend::RequestHandler* quic_stream) {
   const QuicBackendResponse* quic_response = nullptr;
   // Find response in cache. If not found, send error response.
@@ -292,8 +292,8 @@
     quic_response = GetResponse(authority->second, path->second);
   }
 
-  QuicString request_url =
-      QuicString(authority->second) + QuicString(path->second);
+  std::string request_url =
+      std::string(authority->second) + std::string(path->second);
   std::list<ServerPushInfo> resources = GetServerPushResources(request_url);
   QUIC_DVLOG(1)
       << "Fetching QUIC response from backend in-memory cache for url "
@@ -306,7 +306,7 @@
     QuicSimpleServerBackend::RequestHandler* quic_stream) {}
 
 std::list<ServerPushInfo> QuicMemoryCacheBackend::GetServerPushResources(
-    QuicString request_url) {
+    std::string request_url) {
   QuicWriterMutexLock lock(&response_mutex_);
 
   std::list<ServerPushInfo> resources;
@@ -336,7 +336,7 @@
   QuicWriterMutexLock lock(&response_mutex_);
 
   DCHECK(!host.empty()) << "Host must be populated, e.g. \"www.google.com\"";
-  QuicString key = GetKey(host, path);
+  std::string key = GetKey(host, path);
   if (QuicContainsKey(responses_, key)) {
     QUIC_BUG << "Response for '" << key << "' already exists!";
     return;
@@ -351,20 +351,20 @@
   responses_[key] = std::move(new_response);
 }
 
-QuicString QuicMemoryCacheBackend::GetKey(QuicStringPiece host,
-                                          QuicStringPiece path) const {
-  QuicString host_string = QuicString(host);
+std::string QuicMemoryCacheBackend::GetKey(QuicStringPiece host,
+                                           QuicStringPiece path) const {
+  std::string host_string = std::string(host);
   size_t port = host_string.find(':');
-  if (port != QuicString::npos)
-    host_string = QuicString(host_string.c_str(), port);
-  return host_string + QuicString(path);
+  if (port != std::string::npos)
+    host_string = std::string(host_string.c_str(), port);
+  return host_string + std::string(path);
 }
 
 void QuicMemoryCacheBackend::MaybeAddServerPushResources(
     QuicStringPiece request_host,
     QuicStringPiece request_path,
     std::list<ServerPushInfo> push_resources) {
-  QuicString request_url = GetKey(request_host, request_path);
+  std::string request_url = GetKey(request_host, request_path);
 
   for (const auto& push_resource : push_resources) {
     if (PushResourceExistsInCache(request_url, push_resource)) {
@@ -380,11 +380,11 @@
       QuicWriterMutexLock lock(&response_mutex_);
       server_push_resources_.insert(std::make_pair(request_url, push_resource));
     }
-    QuicString host = push_resource.request_url.host();
+    std::string host = push_resource.request_url.host();
     if (host.empty()) {
-      host = QuicString(request_host);
+      host = std::string(request_host);
     }
-    QuicString path = push_resource.request_url.path();
+    std::string path = push_resource.request_url.path();
     bool found_existing_response = false;
     {
       QuicWriterMutexLock lock(&response_mutex_);
@@ -401,7 +401,7 @@
 }
 
 bool QuicMemoryCacheBackend::PushResourceExistsInCache(
-    QuicString original_request_url,
+    std::string original_request_url,
     ServerPushInfo resource) {
   QuicWriterMutexLock lock(&response_mutex_);
   auto resource_range =
diff --git a/quic/tools/quic_memory_cache_backend.h b/quic/tools/quic_memory_cache_backend.h
index 1417349..ff76c9a 100644
--- a/quic/tools/quic_memory_cache_backend.h
+++ b/quic/tools/quic_memory_cache_backend.h
@@ -32,7 +32,7 @@
   // server push associations.
   class ResourceFile {
    public:
-    explicit ResourceFile(const QuicString& file_name);
+    explicit ResourceFile(const std::string& file_name);
     ResourceFile(const ResourceFile&) = delete;
     ResourceFile& operator=(const ResourceFile&) = delete;
     virtual ~ResourceFile();
@@ -42,7 +42,7 @@
     // |base| is |file_name_| with |cache_directory| prefix stripped.
     void SetHostPathFromBase(QuicStringPiece base);
 
-    const QuicString& file_name() { return file_name_; }
+    const std::string& file_name() { return file_name_; }
 
     QuicStringPiece host() { return host_; }
 
@@ -58,8 +58,8 @@
     void HandleXOriginalUrl();
     QuicStringPiece RemoveScheme(QuicStringPiece url);
 
-    QuicString file_name_;
-    QuicString file_contents_;
+    std::string file_name_;
+    std::string file_contents_;
     QuicStringPiece body_;
     spdy::SpdyHeaderBlock spdy_headers_;
     QuicStringPiece x_original_url_;
@@ -135,19 +135,19 @@
   void AddDefaultResponse(QuicBackendResponse* response);
 
   // |cache_cirectory| can be generated using `wget -p --save-headers <url>`.
-  void InitializeFromDirectory(const QuicString& cache_directory);
+  void InitializeFromDirectory(const std::string& cache_directory);
 
   // Find all the server push resources associated with |request_url|.
   std::list<QuicBackendResponse::ServerPushInfo> GetServerPushResources(
-      QuicString request_url);
+      std::string request_url);
 
   // Implements the functions for interface QuicSimpleServerBackend
   // |cache_cirectory| can be generated using `wget -p --save-headers <url>`.
-  bool InitializeBackend(const QuicString& cache_directory) override;
+  bool InitializeBackend(const std::string& cache_directory) override;
   bool IsBackendInitialized() const override;
   void FetchResponseFromBackend(
       const spdy::SpdyHeaderBlock& request_headers,
-      const QuicString& request_body,
+      const std::string& request_body,
       QuicSimpleServerBackend::RequestHandler* quic_server_stream) override;
   void CloseBackendResponseStream(
       QuicSimpleServerBackend::RequestHandler* quic_server_stream) override;
@@ -161,7 +161,7 @@
                        spdy::SpdyHeaderBlock response_trailers,
                        uint16_t stop_sending_code);
 
-  QuicString GetKey(QuicStringPiece host, QuicStringPiece path) const;
+  std::string GetKey(QuicStringPiece host, QuicStringPiece path) const;
 
   // Add some server push urls with given responses for specified
   // request if these push resources are not associated with this request yet.
@@ -172,11 +172,11 @@
 
   // Check if push resource(push_host/push_path) associated with given request
   // url already exists in server push map.
-  bool PushResourceExistsInCache(QuicString original_request_url,
+  bool PushResourceExistsInCache(std::string original_request_url,
                                  QuicBackendResponse::ServerPushInfo resource);
 
   // Cached responses.
-  QuicUnorderedMap<QuicString, std::unique_ptr<QuicBackendResponse>> responses_
+  QuicUnorderedMap<std::string, std::unique_ptr<QuicBackendResponse>> responses_
       GUARDED_BY(response_mutex_);
 
   // The default response for cache misses, if set.
@@ -184,7 +184,7 @@
       GUARDED_BY(response_mutex_);
 
   // A map from request URL to associated server push responses (if any).
-  std::multimap<QuicString, QuicBackendResponse::ServerPushInfo>
+  std::multimap<std::string, QuicBackendResponse::ServerPushInfo>
       server_push_resources_ GUARDED_BY(response_mutex_);
 
   // Protects against concurrent access from test threads setting responses, and
diff --git a/quic/tools/quic_memory_cache_backend_test.cc b/quic/tools/quic_memory_cache_backend_test.cc
index e5f5db1..80b1b29 100644
--- a/quic/tools/quic_memory_cache_backend_test.cc
+++ b/quic/tools/quic_memory_cache_backend_test.cc
@@ -20,8 +20,8 @@
 
 class QuicMemoryCacheBackendTest : public QuicTest {
  protected:
-  void CreateRequest(QuicString host,
-                     QuicString path,
+  void CreateRequest(std::string host,
+                     std::string path,
                      spdy::SpdyHeaderBlock* headers) {
     (*headers)[":method"] = "GET";
     (*headers)[":path"] = path;
@@ -29,7 +29,7 @@
     (*headers)[":scheme"] = "https";
   }
 
-  QuicString CacheDirectory() { return QuicGetTestMemoryCachePath(); }
+  std::string CacheDirectory() { return QuicGetTestMemoryCachePath(); }
 
   QuicMemoryCacheBackend cache_;
 };
@@ -41,7 +41,7 @@
 }
 
 TEST_F(QuicMemoryCacheBackendTest, AddSimpleResponseGetResponse) {
-  QuicString response_body("hello response");
+  std::string response_body("hello response");
   cache_.AddSimpleResponse("www.google.com", "/", 200, response_body);
 
   spdy::SpdyHeaderBlock request_headers;
@@ -54,9 +54,9 @@
 }
 
 TEST_F(QuicMemoryCacheBackendTest, AddResponse) {
-  const QuicString kRequestHost = "www.foo.com";
-  const QuicString kRequestPath = "/";
-  const QuicString kResponseBody("hello response");
+  const std::string kRequestHost = "www.foo.com";
+  const std::string kRequestPath = "/";
+  const std::string kResponseBody("hello response");
 
   spdy::SpdyHeaderBlock response_headers;
   response_headers[":version"] = "HTTP/1.1";
@@ -151,17 +151,17 @@
 }
 
 TEST_F(QuicMemoryCacheBackendTest, AddSimpleResponseWithServerPushResources) {
-  QuicString request_host = "www.foo.com";
-  QuicString response_body("hello response");
+  std::string request_host = "www.foo.com";
+  std::string response_body("hello response");
   const size_t kNumResources = 5;
   int NumResources = 5;
   std::list<ServerPushInfo> push_resources;
-  QuicString scheme = "http";
+  std::string scheme = "http";
   for (int i = 0; i < NumResources; ++i) {
-    QuicString path = "/server_push_src" + QuicTextUtils::Uint64ToString(i);
-    QuicString url = scheme + "://" + request_host + path;
+    std::string path = "/server_push_src" + QuicTextUtils::Uint64ToString(i);
+    std::string url = scheme + "://" + request_host + path;
     QuicUrl resource_url(url);
-    QuicString body =
+    std::string body =
         QuicStrCat("This is server push response body for ", path);
     spdy::SpdyHeaderBlock response_headers;
     response_headers[":version"] = "HTTP/1.1";
@@ -175,7 +175,7 @@
   cache_.AddSimpleResponseWithServerPushResources(
       request_host, "/", 200, response_body, push_resources);
 
-  QuicString request_url = request_host + "/";
+  std::string request_url = request_host + "/";
   std::list<ServerPushInfo> resources =
       cache_.GetServerPushResources(request_url);
   ASSERT_EQ(kNumResources, resources.size());
@@ -189,18 +189,19 @@
 }
 
 TEST_F(QuicMemoryCacheBackendTest, GetServerPushResourcesAndPushResponses) {
-  QuicString request_host = "www.foo.com";
-  QuicString response_body("hello response");
+  std::string request_host = "www.foo.com";
+  std::string response_body("hello response");
   const size_t kNumResources = 4;
   int NumResources = 4;
-  QuicString scheme = "http";
-  QuicString push_response_status[kNumResources] = {"200", "200", "301", "404"};
+  std::string scheme = "http";
+  std::string push_response_status[kNumResources] = {"200", "200", "301",
+                                                     "404"};
   std::list<ServerPushInfo> push_resources;
   for (int i = 0; i < NumResources; ++i) {
-    QuicString path = "/server_push_src" + QuicTextUtils::Uint64ToString(i);
-    QuicString url = scheme + "://" + request_host + path;
+    std::string path = "/server_push_src" + QuicTextUtils::Uint64ToString(i);
+    std::string url = scheme + "://" + request_host + path;
     QuicUrl resource_url(url);
-    QuicString body = "This is server push response body for " + path;
+    std::string body = "This is server push response body for " + path;
     spdy::SpdyHeaderBlock response_headers;
     response_headers[":version"] = "HTTP/1.1";
     response_headers[":status"] = push_response_status[i];
@@ -211,15 +212,15 @@
   }
   cache_.AddSimpleResponseWithServerPushResources(
       request_host, "/", 200, response_body, push_resources);
-  QuicString request_url = request_host + "/";
+  std::string request_url = request_host + "/";
   std::list<ServerPushInfo> resources =
       cache_.GetServerPushResources(request_url);
   ASSERT_EQ(kNumResources, resources.size());
   int i = 0;
   for (const auto& push_resource : push_resources) {
     QuicUrl url = resources.front().request_url;
-    QuicString host = url.host();
-    QuicString path = url.path();
+    std::string host = url.host();
+    std::string path = url.path();
     const Response* response = cache_.GetResponse(host, path);
     ASSERT_TRUE(response);
     ASSERT_TRUE(QuicContainsKey(response->headers(), ":status"));
diff --git a/quic/tools/quic_packet_printer_bin.cc b/quic/tools/quic_packet_printer_bin.cc
index c632195..77906a1 100644
--- a/quic/tools/quic_packet_printer_bin.cc
+++ b/quic/tools/quic_packet_printer_bin.cc
@@ -208,7 +208,7 @@
 
 int main(int argc, char* argv[]) {
   const char* usage = "Usage: quic_packet_printer client|server <hex>";
-  std::vector<quic::QuicString> args =
+  std::vector<std::string> args =
       quic::QuicParseCommandLineFlags(usage, argc, argv);
 
   if (args.size() < 2) {
@@ -216,7 +216,7 @@
     return 1;
   }
 
-  quic::QuicString perspective_string = args[0];
+  std::string perspective_string = args[0];
   quic::Perspective perspective;
   if (perspective_string == "client") {
     perspective = quic::Perspective::IS_CLIENT;
@@ -227,7 +227,7 @@
     quic::QuicPrintCommandLineFlagHelp(usage);
     return 1;
   }
-  quic::QuicString hex = quic::QuicTextUtils::HexDecode(args[1]);
+  std::string hex = quic::QuicTextUtils::HexDecode(args[1]);
   quic::ParsedQuicVersionVector versions = quic::AllSupportedVersions();
   // Fake a time since we're not actually generating acks.
   quic::QuicTime start(quic::QuicTime::Zero());
diff --git a/quic/tools/quic_reject_reason_decoder_bin.cc b/quic/tools/quic_reject_reason_decoder_bin.cc
index 14590b6..de66774 100644
--- a/quic/tools/quic_reject_reason_decoder_bin.cc
+++ b/quic/tools/quic_reject_reason_decoder_bin.cc
@@ -18,7 +18,7 @@
 
 int main(int argc, char* argv[]) {
   const char* usage = "Usage: quic_reject_reason_decoder <packed_reason>";
-  std::vector<quic::QuicString> args =
+  std::vector<std::string> args =
       quic::QuicParseCommandLineFlags(usage, argc, argv);
 
   if (args.size() != 1) {
diff --git a/quic/tools/quic_server.h b/quic/tools/quic_server.h
index 9ef5f0c..a339d1e 100644
--- a/quic/tools/quic_server.h
+++ b/quic/tools/quic_server.h
@@ -48,7 +48,7 @@
 
   ~QuicServer() override;
 
-  QuicString Name() const override { return "QuicServer"; }
+  std::string Name() const override { return "QuicServer"; }
 
   // Start listening on the specified address.
   bool CreateUDPSocketAndListen(const QuicSocketAddress& address);
diff --git a/quic/tools/quic_server_bin.cc b/quic/tools/quic_server_bin.cc
index fde94a3..1029fbd 100644
--- a/quic/tools/quic_server_bin.cc
+++ b/quic/tools/quic_server_bin.cc
@@ -28,7 +28,7 @@
 
 int main(int argc, char* argv[]) {
   const char* usage = "Usage: quic_server [options]";
-  std::vector<quic::QuicString> non_option_args =
+  std::vector<std::string> non_option_args =
       quic::QuicParseCommandLineFlags(usage, argc, argv);
   if (!non_option_args.empty()) {
     quic::QuicPrintCommandLineFlagHelp(usage);
diff --git a/quic/tools/quic_simple_crypto_server_stream_helper.cc b/quic/tools/quic_simple_crypto_server_stream_helper.cc
index bdd6731..2bb9656 100644
--- a/quic/tools/quic_simple_crypto_server_stream_helper.cc
+++ b/quic/tools/quic_simple_crypto_server_stream_helper.cc
@@ -27,7 +27,7 @@
     const QuicSocketAddress& client_address,
     const QuicSocketAddress& peer_address,
     const QuicSocketAddress& self_address,
-    QuicString* error_details) const {
+    std::string* error_details) const {
   return true;
 }
 
diff --git a/quic/tools/quic_simple_crypto_server_stream_helper.h b/quic/tools/quic_simple_crypto_server_stream_helper.h
index c058f1a..f8a58f6 100644
--- a/quic/tools/quic_simple_crypto_server_stream_helper.h
+++ b/quic/tools/quic_simple_crypto_server_stream_helper.h
@@ -27,7 +27,7 @@
                             const QuicSocketAddress& client_address,
                             const QuicSocketAddress& peer_address,
                             const QuicSocketAddress& self_address,
-                            QuicString* error_details) const override;
+                            std::string* error_details) const override;
 
  private:
   QuicRandom* random_;  // Unowned.
diff --git a/quic/tools/quic_simple_server_backend.h b/quic/tools/quic_simple_server_backend.h
index a75143a..74afb60 100644
--- a/quic/tools/quic_simple_server_backend.h
+++ b/quic/tools/quic_simple_server_backend.h
@@ -27,7 +27,7 @@
 
     virtual QuicConnectionId connection_id() const = 0;
     virtual QuicStreamId stream_id() const = 0;
-    virtual QuicString peer_host() const = 0;
+    virtual std::string peer_host() const = 0;
     // Called when the response is ready at the backend and can be send back to
     // the QUIC client.
     virtual void OnResponseBackendComplete(
@@ -38,7 +38,7 @@
   virtual ~QuicSimpleServerBackend() = default;
   // This method initializes the backend instance to fetch responses
   // from a backend server, in-memory cache etc.
-  virtual bool InitializeBackend(const QuicString& backend_url) = 0;
+  virtual bool InitializeBackend(const std::string& backend_url) = 0;
   // Returns true if the backend has been successfully initialized
   // and could be used to fetch HTTP requests
   virtual bool IsBackendInitialized() const = 0;
@@ -49,7 +49,7 @@
   // asynchronously calls |request_handler| with the HTTP response.
   virtual void FetchResponseFromBackend(
       const spdy::SpdyHeaderBlock& request_headers,
-      const QuicString& request_body,
+      const std::string& request_body,
       RequestHandler* request_handler) = 0;
   // Clears the state of the backend  instance
   virtual void CloseBackendResponseStream(RequestHandler* request_handler) = 0;
diff --git a/quic/tools/quic_simple_server_session.cc b/quic/tools/quic_simple_server_session.cc
index 7e2e3bf..a722d37 100644
--- a/quic/tools/quic_simple_server_session.cc
+++ b/quic/tools/quic_simple_server_session.cc
@@ -61,7 +61,7 @@
 }
 
 void QuicSimpleServerSession::PromisePushResources(
-    const QuicString& request_url,
+    const std::string& request_url,
     const std::list<QuicBackendResponse::ServerPushInfo>& resources,
     QuicStreamId original_stream_id,
     const spdy::SpdyHeaderBlock& original_request_headers) {
@@ -160,7 +160,7 @@
 }
 
 spdy::SpdyHeaderBlock QuicSimpleServerSession::SynthesizePushRequestHeaders(
-    QuicString request_url,
+    std::string request_url,
     QuicBackendResponse::ServerPushInfo resource,
     const spdy::SpdyHeaderBlock& original_request_headers) {
   QuicUrl push_request_url = resource.request_url;
diff --git a/quic/tools/quic_simple_server_session.h b/quic/tools/quic_simple_server_session.h
index 45c97d0..81e067d 100644
--- a/quic/tools/quic_simple_server_session.h
+++ b/quic/tools/quic_simple_server_session.h
@@ -74,7 +74,7 @@
   // And enqueue HEADERS block in those PUSH_PROMISED for sending push response
   // later.
   virtual void PromisePushResources(
-      const QuicString& request_url,
+      const std::string& request_url,
       const std::list<QuicBackendResponse::ServerPushInfo>& resources,
       QuicStreamId original_stream_id,
       const spdy::SpdyHeaderBlock& original_request_headers);
@@ -112,7 +112,7 @@
   // Copying the rest headers ensures they are the same as the original
   // request, especially cookies.
   spdy::SpdyHeaderBlock SynthesizePushRequestHeaders(
-      QuicString request_url,
+      std::string request_url,
       QuicBackendResponse::ServerPushInfo resource,
       const spdy::SpdyHeaderBlock& original_request_headers);
 
diff --git a/quic/tools/quic_simple_server_session_test.cc b/quic/tools/quic_simple_server_session_test.cc
index b2ef667..8d5b05c 100644
--- a/quic/tools/quic_simple_server_session_test.cc
+++ b/quic/tools/quic_simple_server_session_test.cc
@@ -601,28 +601,28 @@
     // than stream flow control window so stream won't send the full body.
     size_t body_size = 2 * kStreamFlowControlWindowSize;  // 64KB.
 
-    QuicString request_url = "mail.google.com/";
+    std::string request_url = "mail.google.com/";
     spdy::SpdyHeaderBlock request_headers;
-    QuicString resource_host = "www.google.com";
-    QuicString partial_push_resource_path = "/server_push_src";
+    std::string resource_host = "www.google.com";
+    std::string partial_push_resource_path = "/server_push_src";
     std::list<QuicBackendResponse::ServerPushInfo> push_resources;
-    QuicString scheme = "http";
+    std::string scheme = "http";
     QuicByteCount header_length = 0;
     for (unsigned int i = 1; i <= num_resources; ++i) {
       QuicStreamId stream_id = GetNthServerInitiatedUnidirectionalId(i - 1);
-      QuicString path =
+      std::string path =
           partial_push_resource_path + QuicTextUtils::Uint64ToString(i);
-      QuicString url = scheme + "://" + resource_host + path;
+      std::string url = scheme + "://" + resource_host + path;
       QuicUrl resource_url = QuicUrl(url);
-      QuicString body(body_size, 'a');
-      QuicString data;
+      std::string body(body_size, 'a');
+      std::string data;
       header_length = 0;
       if (VersionHasDataFrameHeader(connection_->transport_version())) {
         HttpEncoder encoder;
         std::unique_ptr<char[]> buffer;
         header_length =
             encoder.SerializeDataFrameHeader(body.length(), &buffer);
-        QuicString header = QuicString(buffer.get(), header_length);
+        std::string header = std::string(buffer.get(), header_length);
         data = header + body;
       } else {
         data = body;
diff --git a/quic/tools/quic_simple_server_stream.cc b/quic/tools/quic_simple_server_stream.cc
index 541ff32..4e25552 100644
--- a/quic/tools/quic_simple_server_stream.cc
+++ b/quic/tools/quic_simple_server_stream.cc
@@ -155,7 +155,7 @@
   return id();
 }
 
-QuicString QuicSimpleServerStream::peer_host() const {
+std::string QuicSimpleServerStream::peer_host() const {
   return spdy_session()->peer_address().host().ToString();
 }
 
@@ -192,8 +192,8 @@
   // response status, send error response. Notice that
   // QuicHttpResponseCache push urls are strictly authority + path only,
   // scheme is not included (see |QuicHttpResponseCache::GetKey()|).
-  QuicString request_url = request_headers_[":authority"].as_string() +
-                           request_headers_[":path"].as_string();
+  std::string request_url = request_headers_[":authority"].as_string() +
+                            request_headers_[":path"].as_string();
   int response_code;
   const SpdyHeaderBlock& response_headers = response->headers();
   if (!ParseHeaderStatusCode(response_headers, &response_code)) {
diff --git a/quic/tools/quic_simple_server_stream.h b/quic/tools/quic_simple_server_stream.h
index 2e6826f..4472262 100644
--- a/quic/tools/quic_simple_server_stream.h
+++ b/quic/tools/quic_simple_server_stream.h
@@ -56,7 +56,7 @@
   // Implements QuicSimpleServerBackend::RequestHandler callbacks
   QuicConnectionId connection_id() const override;
   QuicStreamId stream_id() const override;
-  QuicString peer_host() const override;
+  std::string peer_host() const override;
   void OnResponseBackendComplete(
       const QuicBackendResponse* response,
       std::list<QuicBackendResponse::ServerPushInfo> resources) override;
@@ -87,12 +87,12 @@
 
   spdy::SpdyHeaderBlock* request_headers() { return &request_headers_; }
 
-  const QuicString& body() { return body_; }
+  const std::string& body() { return body_; }
 
   // The parsed headers received from the client.
   spdy::SpdyHeaderBlock request_headers_;
   int64_t content_length_;
-  QuicString body_;
+  std::string body_;
 
  private:
   QuicSimpleServerBackend* quic_simple_server_backend_;  // Not owned.
diff --git a/quic/tools/quic_simple_server_stream_test.cc b/quic/tools/quic_simple_server_stream_test.cc
index 88c85e4..7572a75 100644
--- a/quic/tools/quic_simple_server_stream_test.cc
+++ b/quic/tools/quic_simple_server_stream_test.cc
@@ -68,8 +68,8 @@
   void DoSendErrorResponse() { SendErrorResponse(); }
 
   spdy::SpdyHeaderBlock* mutable_headers() { return &request_headers_; }
-  void set_body(QuicString body) { body_ = std::move(body); }
-  const QuicString& body() const { return body_; }
+  void set_body(std::string body) { body_ = std::move(body); }
+  const std::string& body() const { return body_; }
   int content_length() const { return content_length_; }
 
   QuicStringPiece GetHeader(QuicStringPiece key) const {
@@ -113,7 +113,7 @@
 
   MOCK_METHOD3(OnConnectionClosed,
                void(QuicErrorCode error,
-                    const QuicString& error_details,
+                    const std::string& error_details,
                     ConnectionCloseSource source));
   MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(QuicStreamId id));
   MOCK_METHOD5(WritevData,
@@ -136,7 +136,7 @@
   MOCK_METHOD1(OnHeadersHeadOfLineBlocking, void(QuicTime::Delta delta));
   // Matchers cannot be used on non-copyable types like SpdyHeaderBlock.
   void PromisePushResources(
-      const QuicString& request_url,
+      const std::string& request_url,
       const std::list<QuicBackendResponse::ServerPushInfo>& resources,
       QuicStreamId original_stream_id,
       const spdy::SpdyHeaderBlock& original_request_headers) override {
@@ -145,7 +145,7 @@
                              original_request_headers);
   }
   MOCK_METHOD4(PromisePushResourcesMock,
-               void(const QuicString&,
+               void(const std::string&,
                     const std::list<QuicBackendResponse::ServerPushInfo>&,
                     QuicStreamId,
                     const spdy::SpdyHeaderBlock&));
@@ -206,9 +206,9 @@
     connection_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
   }
 
-  const QuicString& StreamBody() { return stream_->body(); }
+  const std::string& StreamBody() { return stream_->body(); }
 
-  QuicString StreamHeadersValue(const QuicString& key) {
+  std::string StreamHeadersValue(const std::string& key) {
     return (*stream_->mutable_headers())[key].as_string();
   }
 
@@ -232,7 +232,7 @@
   StrictMock<MockQuicSimpleServerSession> session_;
   StrictMock<TestStream>* stream_;  // Owned by session_.
   std::unique_ptr<QuicBackendResponse> quic_response_;
-  QuicString body_;
+  std::string body_;
   QuicHeaderList header_list_;
   HttpEncoder encoder_;
 };
@@ -248,8 +248,8 @@
   std::unique_ptr<char[]> buffer;
   QuicByteCount header_length =
       encoder_.SerializeDataFrameHeader(body_.length(), &buffer);
-  QuicString header = QuicString(buffer.get(), header_length);
-  QuicString data = HasFrameHeader() ? header + body_ : body_;
+  std::string header = std::string(buffer.get(), header_length);
+  std::string data = HasFrameHeader() ? header + body_ : body_;
   stream_->OnStreamFrame(
       QuicStreamFrame(stream_->id(), /*fin=*/false, /*offset=*/0, data));
   EXPECT_EQ("11", StreamHeadersValue("content-length"));
@@ -266,8 +266,8 @@
   std::unique_ptr<char[]> buffer;
   QuicByteCount header_length =
       encoder_.SerializeDataFrameHeader(body_.length(), &buffer);
-  QuicString header = QuicString(buffer.get(), header_length);
-  QuicString data = HasFrameHeader() ? header + body_ : body_;
+  std::string header = std::string(buffer.get(), header_length);
+  std::string data = HasFrameHeader() ? header + body_ : body_;
   stream_->OnStreamFrame(
       QuicStreamFrame(stream_->id(), /*fin=*/false, /*offset=*/0, data));
   EXPECT_EQ("11", StreamHeadersValue("content-length"));
@@ -292,7 +292,7 @@
 
 TEST_P(QuicSimpleServerStreamTest, TestFramingExtraData) {
   InSequence seq;
-  QuicString large_body = "hello world!!!!!!";
+  std::string large_body = "hello world!!!!!!";
 
   // We'll automatically write out an error (headers + body)
   EXPECT_CALL(*stream_, WriteHeadersMock(false));
@@ -307,8 +307,8 @@
   std::unique_ptr<char[]> buffer;
   QuicByteCount header_length =
       encoder_.SerializeDataFrameHeader(body_.length(), &buffer);
-  QuicString header = QuicString(buffer.get(), header_length);
-  QuicString data = HasFrameHeader() ? header + body_ : body_;
+  std::string header = std::string(buffer.get(), header_length);
+  std::string data = HasFrameHeader() ? header + body_ : body_;
 
   stream_->OnStreamFrame(
       QuicStreamFrame(stream_->id(), /*fin=*/false, /*offset=*/0, data));
@@ -316,8 +316,8 @@
   // accept the bytes.
   header_length =
       encoder_.SerializeDataFrameHeader(large_body.length(), &buffer);
-  header = QuicString(buffer.get(), header_length);
-  QuicString data2 = HasFrameHeader() ? header + large_body : large_body;
+  header = std::string(buffer.get(), header_length);
+  std::string data2 = HasFrameHeader() ? header + large_body : large_body;
   stream_->OnStreamFrame(
       QuicStreamFrame(stream_->id(), /*fin=*/true, data.size(), data2));
   EXPECT_EQ("11", StreamHeadersValue("content-length"));
@@ -337,7 +337,7 @@
   // HTTP/2 only supports integer responsecode, so "200 OK" is illegal.
   response_headers_[":status"] = "200 OK";
   response_headers_["content-length"] = "5";
-  QuicString body = "Yummm";
+  std::string body = "Yummm";
   std::unique_ptr<char[]> buffer;
   QuicByteCount header_length =
       encoder_.SerializeDataFrameHeader(body.length(), &buffer);
@@ -371,7 +371,7 @@
   // HTTP/2 only supports 3-digit-integer, so "+200" is illegal.
   response_headers_[":status"] = "+200";
   response_headers_["content-length"] = "5";
-  QuicString body = "Yummm";
+  std::string body = "Yummm";
 
   std::unique_ptr<char[]> buffer;
   QuicByteCount header_length =
@@ -413,7 +413,7 @@
   response_headers_[":version"] = "HTTP/1.1";
   response_headers_[":status"] = "404";
   response_headers_["content-length"] = "8";
-  QuicString body = "NotFound";
+  std::string body = "NotFound";
 
   memory_cache_backend_.AddResponse("www.google.com", "/bar",
                                     std::move(response_headers_), body);
@@ -436,7 +436,7 @@
   response_headers_[":version"] = "HTTP/1.1";
   response_headers_[":status"] = "200";
   response_headers_["content-length"] = "5";
-  QuicString body = "Yummm";
+  std::string body = "Yummm";
 
   std::unique_ptr<char[]> buffer;
   QuicByteCount header_length =
@@ -463,9 +463,9 @@
   // call PromisePushResources() to handle these resources.
 
   // Add a request and response with valid headers into cache.
-  QuicString host = "www.google.com";
-  QuicString request_path = "/foo";
-  QuicString body = "Yummm";
+  std::string host = "www.google.com";
+  std::string request_path = "/foo";
+  std::string body = "Yummm";
   std::unique_ptr<char[]> buffer;
   QuicByteCount header_length =
       encoder_.SerializeDataFrameHeader(body.length(), &buffer);
@@ -526,8 +526,8 @@
                                  WRITE_UNIDIRECTIONAL, &memory_cache_backend_);
   session_.ActivateStream(QuicWrapUnique(server_initiated_stream));
 
-  const QuicString kHost = "www.foo.com";
-  const QuicString kPath = "/bar";
+  const std::string kHost = "www.foo.com";
+  const std::string kPath = "/bar";
   spdy::SpdyHeaderBlock headers;
   headers[":path"] = kPath;
   headers[":authority"] = kHost;
@@ -537,7 +537,7 @@
   response_headers_[":version"] = "HTTP/1.1";
   response_headers_[":status"] = "200";
   response_headers_["content-length"] = "5";
-  const QuicString kBody = "Hello";
+  const std::string kBody = "Hello";
   std::unique_ptr<char[]> buffer;
   QuicByteCount header_length =
       encoder_.SerializeDataFrameHeader(kBody.length(), &buffer);
diff --git a/quic/tools/quic_spdy_client_base.cc b/quic/tools/quic_spdy_client_base.cc
index b9b0bd2..3d7ef02 100644
--- a/quic/tools/quic_spdy_client_base.cc
+++ b/quic/tools/quic_spdy_client_base.cc
@@ -132,7 +132,7 @@
 }
 
 void QuicSpdyClientBase::SendRequestsAndWaitForResponse(
-    const std::vector<QuicString>& url_list) {
+    const std::vector<std::string>& url_list) {
   for (size_t i = 0; i < url_list.size(); ++i) {
     SpdyHeaderBlock headers;
     if (!SpdyUtils::PopulateHeaderBlockFromUrl(url_list[i], &headers)) {
@@ -240,12 +240,12 @@
   return latest_response_code_;
 }
 
-const QuicString& QuicSpdyClientBase::latest_response_headers() const {
+const std::string& QuicSpdyClientBase::latest_response_headers() const {
   QUIC_BUG_IF(!store_response_) << "Response not stored!";
   return latest_response_headers_;
 }
 
-const QuicString& QuicSpdyClientBase::preliminary_response_headers() const {
+const std::string& QuicSpdyClientBase::preliminary_response_headers() const {
   QUIC_BUG_IF(!store_response_) << "Response not stored!";
   return preliminary_response_headers_;
 }
@@ -256,12 +256,12 @@
   return latest_response_header_block_;
 }
 
-const QuicString& QuicSpdyClientBase::latest_response_body() const {
+const std::string& QuicSpdyClientBase::latest_response_body() const {
   QUIC_BUG_IF(!store_response_) << "Response not stored!";
   return latest_response_body_;
 }
 
-const QuicString& QuicSpdyClientBase::latest_response_trailers() const {
+const std::string& QuicSpdyClientBase::latest_response_trailers() const {
   QUIC_BUG_IF(!store_response_) << "Response not stored!";
   return latest_response_trailers_;
 }
diff --git a/quic/tools/quic_spdy_client_base.h b/quic/tools/quic_spdy_client_base.h
index 3112f9c..a9aadb9 100644
--- a/quic/tools/quic_spdy_client_base.h
+++ b/quic/tools/quic_spdy_client_base.h
@@ -37,7 +37,7 @@
     virtual void OnCompleteResponse(
         QuicStreamId id,
         const spdy::SpdyHeaderBlock& response_headers,
-        const QuicString& response_body) = 0;
+        const std::string& response_body) = 0;
   };
 
   // The client uses these objects to keep track of any data to resend upon
@@ -99,7 +99,7 @@
 
   // Sends a request simple GET for each URL in |url_list|, and then waits for
   // each to complete.
-  void SendRequestsAndWaitForResponse(const std::vector<QuicString>& url_list);
+  void SendRequestsAndWaitForResponse(const std::vector<std::string>& url_list);
 
   // Returns a newly created QuicSpdyClientStream.
   QuicSpdyClientStream* CreateClientStream();
@@ -126,11 +126,11 @@
   void set_store_response(bool val) { store_response_ = val; }
 
   size_t latest_response_code() const;
-  const QuicString& latest_response_headers() const;
-  const QuicString& preliminary_response_headers() const;
+  const std::string& latest_response_headers() const;
+  const std::string& preliminary_response_headers() const;
   const spdy::SpdyHeaderBlock& latest_response_header_block() const;
-  const QuicString& latest_response_body() const;
-  const QuicString& latest_response_trailers() const;
+  const std::string& latest_response_body() const;
+  const std::string& latest_response_trailers() const;
 
   void set_response_listener(std::unique_ptr<ResponseListener> listener) {
     response_listener_ = std::move(listener);
@@ -192,15 +192,15 @@
   // HTTP response code from most recent response.
   int latest_response_code_;
   // HTTP/2 headers from most recent response.
-  QuicString latest_response_headers_;
+  std::string latest_response_headers_;
   // preliminary 100 Continue HTTP/2 headers from most recent response, if any.
-  QuicString preliminary_response_headers_;
+  std::string preliminary_response_headers_;
   // HTTP/2 headers from most recent response.
   spdy::SpdyHeaderBlock latest_response_header_block_;
   // Body of most recent response.
-  QuicString latest_response_body_;
+  std::string latest_response_body_;
   // HTTP/2 trailers from most recent response.
-  QuicString latest_response_trailers_;
+  std::string latest_response_trailers_;
 
   // Listens for full responses.
   std::unique_ptr<ResponseListener> response_listener_;
diff --git a/quic/tools/quic_url.cc b/quic/tools/quic_url.cc
index 675cafe..4094ffe 100644
--- a/quic/tools/quic_url.cc
+++ b/quic/tools/quic_url.cc
@@ -11,7 +11,7 @@
 
 static constexpr size_t kMaxHostNameLength = 256;
 
-QuicUrl::QuicUrl(QuicStringPiece url) : url_(static_cast<QuicString>(url)) {}
+QuicUrl::QuicUrl(QuicStringPiece url) : url_(static_cast<std::string>(url)) {}
 
 QuicUrl::QuicUrl(QuicStringPiece url, QuicStringPiece default_scheme)
     : QuicUrl(url) {
@@ -22,7 +22,7 @@
   url_ = GURL(QuicStrCat(default_scheme, "://", url));
 }
 
-QuicString QuicUrl::ToString() const {
+std::string QuicUrl::ToString() const {
   if (IsValid()) {
     return url_.spec();
   }
@@ -41,12 +41,12 @@
   return true;
 }
 
-QuicString QuicUrl::HostPort() const {
+std::string QuicUrl::HostPort() const {
   if (!IsValid() || !url_.has_host()) {
     return "";
   }
 
-  QuicString host = url_.host();
+  std::string host = url_.host();
   int port = url_.IntPort();
   if (port == url::PORT_UNSPECIFIED) {
     return host;
@@ -54,7 +54,7 @@
   return QuicStrCat(host, ":", port);
 }
 
-QuicString QuicUrl::PathParamsQuery() const {
+std::string QuicUrl::PathParamsQuery() const {
   if (!IsValid() || !url_.has_path()) {
     return "/";
   }
@@ -62,7 +62,7 @@
   return url_.PathForRequest();
 }
 
-QuicString QuicUrl::scheme() const {
+std::string QuicUrl::scheme() const {
   if (!IsValid()) {
     return "";
   }
@@ -70,7 +70,7 @@
   return url_.scheme();
 }
 
-QuicString QuicUrl::host() const {
+std::string QuicUrl::host() const {
   if (!IsValid()) {
     return "";
   }
@@ -78,7 +78,7 @@
   return url_.HostNoBrackets();
 }
 
-QuicString QuicUrl::path() const {
+std::string QuicUrl::path() const {
   if (!IsValid()) {
     return "";
   }
diff --git a/quic/tools/quic_url.h b/quic/tools/quic_url.h
index f632a9a..7ed190d 100644
--- a/quic/tools/quic_url.h
+++ b/quic/tools/quic_url.h
@@ -34,21 +34,21 @@
 
   // Returns full text of the QuicUrl if it is valid. Return empty string
   // otherwise.
-  QuicString ToString() const;
+  std::string ToString() const;
 
   // Returns host:port.
   // If the host is empty, it will return an empty string.
   // If the host is an IPv6 address, it will be bracketed.
   // If port is not present or is equal to default_port of scheme (e.g., port
   // 80 for HTTP), it won't be returned.
-  QuicString HostPort() const;
+  std::string HostPort() const;
 
   // Returns a string assembles path, parameters and query.
-  QuicString PathParamsQuery() const;
+  std::string PathParamsQuery() const;
 
-  QuicString scheme() const;
-  QuicString host() const;
-  QuicString path() const;
+  std::string scheme() const;
+  std::string host() const;
+  std::string path() const;
   uint16_t port() const;
 
  private:
diff --git a/quic/tools/quic_url_test.cc b/quic/tools/quic_url_test.cc
index 384dc2a..3af0be7 100644
--- a/quic/tools/quic_url_test.cc
+++ b/quic/tools/quic_url_test.cc
@@ -16,7 +16,7 @@
 
 TEST_F(QuicUrlTest, Basic) {
   // No scheme specified.
-  QuicString url_str = "www.example.com";
+  std::string url_str = "www.example.com";
   QuicUrl url(url_str);
   EXPECT_FALSE(url.IsValid());
 
@@ -54,7 +54,7 @@
 
 TEST_F(QuicUrlTest, DefaultScheme) {
   // Default scheme to HTTP.
-  QuicString url_str = "www.example.com";
+  std::string url_str = "www.example.com";
   QuicUrl url(url_str, "http");
   EXPECT_EQ("http://www.example.com/", url.ToString());
   EXPECT_EQ("http", url.scheme());
@@ -73,7 +73,7 @@
 }
 
 TEST_F(QuicUrlTest, IsValid) {
-  QuicString url_str =
+  std::string url_str =
       "ftp://www.example.com:12345/path/to/resource?a=1&campaign=2";
   EXPECT_TRUE(QuicUrl(url_str).IsValid());
 
@@ -86,7 +86,7 @@
   EXPECT_FALSE(QuicUrl(url_str).IsValid());
 
   // Host name too long.
-  QuicString host(1024, 'a');
+  std::string host(1024, 'a');
   url_str = "https://" + host;
   EXPECT_FALSE(QuicUrl(url_str).IsValid());
 
@@ -96,7 +96,7 @@
 }
 
 TEST_F(QuicUrlTest, HostPort) {
-  QuicString url_str = "http://www.example.com/";
+  std::string url_str = "http://www.example.com/";
   QuicUrl url(url_str);
   EXPECT_EQ("www.example.com", url.HostPort());
   EXPECT_EQ("www.example.com", url.host());
@@ -134,7 +134,7 @@
 }
 
 TEST_F(QuicUrlTest, PathParamsQuery) {
-  QuicString url_str =
+  std::string url_str =
       "https://www.example.com:12345/path/to/resource?a=1&campaign=2";
   QuicUrl url(url_str);
   EXPECT_EQ("/path/to/resource?a=1&campaign=2", url.PathParamsQuery());