Port QuicServer to Chrome network stack

net/quic/quic_in_memory_cache.cc

 // Copyright 2014 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/quic/quic_in_memory_cache.h"
 
-#include "base/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/tools/balsa/balsa_headers.h"
 
 using base::FilePath;
 using base::StringPiece;
 using std::string;
 
 // Specifies the directory used during QuicInMemoryCache
 // construction to seed the cache. Cache directory can be
 // generated using `wget -p --save-headers <url>
 
 namespace net {
 
+FilePath::StringType g_quic_in_memory_cache_dir = FILE_PATH_LITERAL("");
+
 namespace {
 
-const FilePath::CharType* g_quic_in_memory_cache_dir = FILE_PATH_LITERAL("");
-
 // BalsaVisitor implementation (glue) which caches response bodies.
 class CachingBalsaVisitor : public NoOpBalsaVisitor {
  public:
   CachingBalsaVisitor() : done_framing_(false) {}
   virtual void ProcessBodyData(const char* input, size_t size) OVERRIDE {
     AppendToBody(input, size);
   }
   virtual void MessageDone() OVERRIDE {
     done_framing_ = true;
   }
@@ skipping 45 matching lines @@
                                           StringPiece response_code,
                                           StringPiece response_detail,
                                           StringPiece body) {
   BalsaHeaders request_headers, response_headers;
   request_headers.SetRequestFirstlineFromStringPieces(method,
                                                       path,
                                                       version);
   response_headers.SetRequestFirstlineFromStringPieces(version,
                                                        response_code,
                                                        response_detail);
-  response_headers.AppendHeader("content-length",
-                                base::IntToString(body.length()));
+  response_headers.AppendHeader(
+      "content-length",
+      base::Uint64ToString(static_cast<uint64>(body.length())));
 
   AddResponse(request_headers, response_headers, body);
 }
 
 void QuicInMemoryCache::AddResponse(const BalsaHeaders& request_headers,
                                     const BalsaHeaders& response_headers,
                                     StringPiece response_body) {
   VLOG(1) << "Adding response for: " << GetKey(request_headers);
   if (ContainsKey(responses_, GetKey(request_headers))) {
     LOG(DFATAL) << "Response for given request already exists!";
@@ skipping 21 matching lines @@
   Initialize();
 }
 
 void QuicInMemoryCache::ResetForTests() {
   STLDeleteValues(&responses_);
   Initialize();
 }
 
 void QuicInMemoryCache::Initialize() {
   // If there's no defined cache dir, we have no initialization to do.
-  if (g_quic_in_memory_cache_dir[0] == '\0') {
+  if (g_quic_in_memory_cache_dir.size() == 0) {
     VLOG(1) << "No cache directory found. Skipping initialization.";
     return;
   }
   VLOG(1) << "Attempting to initialize QuicInMemoryCache from directory: "
           << g_quic_in_memory_cache_dir;
 
   FilePath directory(g_quic_in_memory_cache_dir);
   base::FileEnumerator file_list(directory,
                                  true,
                                  base::FileEnumerator::FILES);
@@ skipping 32 matching lines @@
     }
     if (processed < file_contents.length()) {
       // Didn't frame whole file. Assume remainder is body.
       // This sometimes happens as a result of incompatibilities between
       // BalsaFramer and wget's serialization of HTTP sans content-length.
       caching_visitor.AppendToBody(file_contents.c_str() + processed,
                                    file_contents.length() - processed);
       processed += file_contents.length();
     }
 
-    StringPiece base = file.AsUTF8Unsafe();
+    string utf8_file = file.AsUTF8Unsafe();
+    StringPiece base = utf8_file;
     if (response_headers.HasHeader("X-Original-Url")) {
       base = response_headers.GetHeader("X-Original-Url");
       response_headers.RemoveAllOfHeader("X-Original-Url");
       // Remove the protocol so that the string is of the form host + path,
       // which is parsed properly below.
       if (StringPieceUtils::StartsWithIgnoreCase(base, "https://")) {
         base.remove_prefix(8);
       } else if (StringPieceUtils::StartsWithIgnoreCase(base, "http://")) {
         base.remove_prefix(7);
       }
     }
-    int path_start = base.find_first_of('/');
-    DCHECK_LT(0, path_start);
+    size_t path_start = base.find_first_of('/');
+    DCHECK_LT(0U, path_start);
     StringPiece host(base.substr(0, path_start));
     StringPiece path(base.substr(path_start));
     if (path[path.length() - 1] == ',') {
       path.remove_suffix(1);
     }
     // Set up request headers. Assume method is GET and protocol is HTTP/1.1.
     request_headers.SetRequestFirstlineFromStringPieces("GET",
                                                         path,
                                                         "HTTP/1.1");
     request_headers.ReplaceOrAppendHeader("host", host);
@@ skipping 21 matching lines @@
     host = request_headers.GetHeader("host");
   } else if (StringPieceUtils::StartsWithIgnoreCase(uri, "https://")) {
     uri.remove_prefix(8);
   } else if (StringPieceUtils::StartsWithIgnoreCase(uri, "http://")) {
     uri.remove_prefix(7);
   }
   return host.as_string() + uri.as_string();
 }
 
 }  // namespace net