Add a new QUIC platform API for text utilities.

net/tools/quic/quic_http_response_cache.cc

 // Copyright (c) 2012 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.
 
 #include "net/tools/quic/quic_http_response_cache.h"
 
 #include <utility>
 
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/string_util.h"
-#include "base/strings/stringprintf.h"
 #include "net/http/http_util.h"
 #include "net/quic/core/quic_bug_tracker.h"
+#include "net/quic/platform/api/quic_text_utils.h"
 #include "net/spdy/spdy_http_utils.h"
 
 using base::FilePath;
 using base::IntToString;
 using base::StringPiece;
 using std::string;
 
 namespace net {
 
 QuicHttpResponseCache::ServerPushInfo::ServerPushInfo(
@@ skipping 53 matching lines @@
       continue;
     }
     // Headers are "key: value".
     pos = line.find(": ");
     if (pos == string::npos) {
       LOG(DFATAL) << "Headers invalid or empty, ignoring: "
                   << file_name_.value();
       return;
     }
     spdy_headers_.AppendValueOrAddHeader(
-        base::ToLowerASCII(line.substr(0, pos)), line.substr(pos + 2));
+        QuicTextUtils::ToLower(line.substr(0, pos)), line.substr(pos + 2));
   }
 
   // The connection header is prohibited in HTTP/2.
   spdy_headers_.erase("connection");
 
   // Override the URL with the X-Original-Url header, if present.
   auto it = spdy_headers_.find("x-original-url");
   if (it != spdy_headers_.end()) {
     x_original_url_ = it->second;
     HandleXOriginalUrl();
@@ skipping 35 matching lines @@
   host_ = base.substr(0, path_start);
   size_t query_start = base.find_first_of(',');
   if (query_start > 0) {
     path_ = base.substr(path_start, query_start - 1);
   } else {
     path_ = base.substr(path_start);
   }
 }
 
 StringPiece QuicHttpResponseCache::ResourceFile::RemoveScheme(StringPiece url) {
-  if (base::StartsWith(url, "https://", base::CompareCase::INSENSITIVE_ASCII)) {
+  if (QuicTextUtils::StartsWith(url, "https://")) {
     url.remove_prefix(8);
-  } else if (base::StartsWith(url, "http://",
-                              base::CompareCase::INSENSITIVE_ASCII)) {
+  } else if (QuicTextUtils::StartsWith(url, "http://")) {
     url.remove_prefix(7);
   }
   return url;
 }
 
 void QuicHttpResponseCache::ResourceFile::HandleXOriginalUrl() {
   StringPiece url(x_original_url_);
   // Remove the protocol so we can add it below.
   url = RemoveScheme(url);
   SetHostPathFromBase(url);
@@ skipping 16 matching lines @@
   return it->second.get();
 }
 
 typedef QuicHttpResponseCache::ServerPushInfo ServerPushInfo;
 
 void QuicHttpResponseCache::AddSimpleResponse(StringPiece host,
                                               StringPiece path,
                                               int response_code,
                                               StringPiece body) {
   SpdyHeaderBlock response_headers;
-  response_headers[":status"] = IntToString(response_code);
+  response_headers[":status"] = QuicTextUtils::Uint64ToString(response_code);
   response_headers["content-length"] =
-      IntToString(static_cast<int>(body.length()));
+      QuicTextUtils::Uint64ToString(body.length());
   AddResponse(host, path, std::move(response_headers), body);
 }
 
 void QuicHttpResponseCache::AddSimpleResponseWithServerPushResources(
     StringPiece host,
     StringPiece path,
     int response_code,
     StringPiece body,
     std::list<ServerPushInfo> push_resources) {
   AddSimpleResponse(host, path, response_code, body);
@@ skipping 182 matching lines @@
   for (auto it = resource_range.first; it != resource_range.second; ++it) {
     ServerPushInfo push_resource = it->second;
     if (push_resource.request_url.spec() == resource.request_url.spec()) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace net