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 g_quic_in_memory_cache_dir = FilePath(FILE_PATH_LITERAL(""));

[wtc, 2014/06/18 02:04:46]

Global objects are banned in Chromium. We can probably make an exception because
this file is only used in tests, but we should try to avoid this.

Can this global variable be a FilePath::CharType string?

[dmziegler, 2014/06/18 20:13:41]

I've made it a FilePath::StringType.

In general, we should think about how QuicServer/QuicDispatcher can provide an
actual interface to let you pass in what you want to serve (whether that's a
WebRTC connection or actual content), rather than always serving a
QuicSpdyServerStream and always initializing QuicInMemoryCache with this global
variable hack.

+
 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 88 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.value().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;
+          << g_quic_in_memory_cache_dir.value();
 
-  FilePath directory(g_quic_in_memory_cache_dir);
-  base::FileEnumerator file_list(directory,
+  base::FileEnumerator file_list(g_quic_in_memory_cache_dir,
                                  true,
                                  base::FileEnumerator::FILES);
 
   FilePath file = file_list.Next();
   while (!file.empty()) {
     // Need to skip files in .svn directories
     if (file.value().find(FILE_PATH_LITERAL("/.svn/")) != std::string::npos) {
       file = file_list.Next();
       continue;
     }
@@ skipping 24 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 utf8File = file.AsUTF8Unsafe();

[wtc, 2014/06/18 02:04:46]

Name this variable "utf8_file".

Actually you should be able to name this variable "base" and delete the
StringPiece "base" variable. A StringPiece can be automatically constructed from
a std::string.

[dmziegler, 2014/06/18 20:13:41]

This would require more unnecessary copying, since "base =
response_headers.GetHeader("X-Original-Url")" would have to construct a
std::string out of a StringPiece and the remove_prefix calls on lines 194 and
196 would have to copy out the suffix. Do you think that would be better anyway?

[dmz, 2014/06/19 20:06:28]

Update: My next CL changes things anyway.

+    StringPiece base = utf8File;
     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);
       }
@@ skipping 34 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