Add a new QUIC platform API for text utilities.

net/tools/quic/quic_http_response_cache_test.cc

 // Copyright 2013 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 <string>
 
 #include "base/files/file_path.h"
 #include "base/memory/singleton.h"
 #include "base/path_service.h"
 #include "base/stl_util.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/string_piece.h"
 #include "net/quic/platform/api/quic_str_cat.h"
+#include "net/quic/platform/api/quic_text_utils.h"
 #include "net/spdy/spdy_framer.h"
 #include "net/tools/quic/quic_http_response_cache.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::ContainsKey;
-using base::IntToString;
 using base::StringPiece;
 using net::SpdyHeaderBlock;
 using std::string;
 
 namespace net {
 namespace test {
 
 namespace {
 typedef QuicHttpResponseCache::Response Response;
 typedef QuicHttpResponseCache::ServerPushInfo ServerPushInfo;
@@ skipping 41 matching lines @@
 }
 
 TEST_F(QuicHttpResponseCacheTest, AddResponse) {
   const string kRequestHost = "www.foo.com";
   const string kRequestPath = "/";
   const string kResponseBody("hello response");
 
   SpdyHeaderBlock response_headers;
   response_headers[":version"] = "HTTP/1.1";
   response_headers[":status"] = "200";
-  response_headers["content-length"] = IntToString(kResponseBody.size());
+  response_headers["content-length"] =
+      QuicTextUtils::Uint64ToString(kResponseBody.size());
 
   SpdyHeaderBlock response_trailers;
   response_trailers["key-1"] = "value-1";
   response_trailers["key-2"] = "value-2";
   response_trailers["key-3"] = "value-3";
 
   cache_.AddResponse(kRequestHost, "/", response_headers.Clone(), kResponseBody,
                      response_trailers.Clone());
 
   const QuicHttpResponseCache::Response* response =
@@ skipping 78 matching lines @@
 }
 
 TEST_F(QuicHttpResponseCacheTest, AddSimpleResponseWithServerPushResources) {
   string request_host = "www.foo.com";
   string response_body("hello response");
   const size_t kNumResources = 5;
   int NumResources = 5;
   std::list<QuicHttpResponseCache::ServerPushInfo> push_resources;
   string scheme = "http";
   for (int i = 0; i < NumResources; ++i) {
-    string path = "/server_push_src" + base::IntToString(i);
+    string path = "/server_push_src" + QuicTextUtils::Uint64ToString(i);
     string url = scheme + "://" + request_host + path;
     GURL resource_url(url);
     string body = QuicStrCat("This is server push response body for ", path);
     SpdyHeaderBlock response_headers;
     response_headers[":version"] = "HTTP/1.1";
     response_headers[":status"] = "200";
-    response_headers["content-length"] = base::UintToString(body.size());
+    response_headers["content-length"] =
+        QuicTextUtils::Uint64ToString(body.size());
     push_resources.push_back(
         ServerPushInfo(resource_url, response_headers.Clone(), i, body));
   }
 
   cache_.AddSimpleResponseWithServerPushResources(
       request_host, "/", 200, response_body, push_resources);
   string request_url = request_host + "/";
   std::list<ServerPushInfo> resources =
       cache_.GetServerPushResources(request_url);
   ASSERT_EQ(kNumResources, resources.size());
   for (const auto& push_resource : push_resources) {
     ServerPushInfo resource = resources.front();
     EXPECT_EQ(resource.request_url.spec(), push_resource.request_url.spec());
     EXPECT_EQ(resource.priority, push_resource.priority);
     resources.pop_front();
   }
 }
 
 TEST_F(QuicHttpResponseCacheTest, GetServerPushResourcesAndPushResponses) {
   string request_host = "www.foo.com";
   string response_body("hello response");
   const size_t kNumResources = 4;
   int NumResources = 4;
   string scheme = "http";
   string push_response_status[kNumResources] = {"200", "200", "301", "404"};
   std::list<QuicHttpResponseCache::ServerPushInfo> push_resources;
   for (int i = 0; i < NumResources; ++i) {
-    string path = "/server_push_src" + base::IntToString(i);
+    string path = "/server_push_src" + QuicTextUtils::Uint64ToString(i);
     string url = scheme + "://" + request_host + path;
     GURL resource_url(url);
     string body = "This is server push response body for " + path;
     SpdyHeaderBlock response_headers;
     response_headers[":version"] = "HTTP/1.1";
     response_headers[":status"] = push_response_status[i];
-    response_headers["content-length"] = base::UintToString(body.size());
+    response_headers["content-length"] =
+        QuicTextUtils::Uint64ToString(body.size());
     push_resources.push_back(
         ServerPushInfo(resource_url, response_headers.Clone(), i, body));
   }
   cache_.AddSimpleResponseWithServerPushResources(
       request_host, "/", 200, response_body, push_resources);
   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) {
     GURL url = resources.front().request_url;
     string host = url.host();
     string path = url.path();
     const QuicHttpResponseCache::Response* response =
         cache_.GetResponse(host, path);
     ASSERT_TRUE(response);
     ASSERT_TRUE(ContainsKey(response->headers(), ":status"));
     EXPECT_EQ(push_response_status[i++],
               response->headers().find(":status")->second);
     EXPECT_EQ(push_resource.body, response->body());
     resources.pop_front();
   }
 }
 
 }  // namespace test
 }  // namespace net