Make some changes to the QuicInMemory server to clarify the interface.

net/tools/quic/quic_in_memory_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_in_memory_cache.h"
 
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.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;
 
+namespace net {
+namespace tools {
+
 // Specifies the directory used during QuicInMemoryCache
 // construction to seed the cache. Cache directory can be
 // generated using `wget -p --save-headers <url>
-
-namespace net {
-namespace tools {
-
-std::string FLAGS_quic_in_memory_cache_dir = "";
+string FLAGS_quic_in_memory_cache_dir = "";
 
 namespace {
 
 // BalsaVisitor implementation (glue) which caches response bodies.
 class CachingBalsaVisitor : public NoOpBalsaVisitor {
  public:
   CachingBalsaVisitor() : done_framing_(false) {}
   void ProcessBodyData(const char* input, size_t size) override {
     AppendToBody(input, size);
   }
@@ skipping 17 matching lines @@
 };
 
 }  // namespace
 
 // static
 QuicInMemoryCache* QuicInMemoryCache::GetInstance() {
   return Singleton<QuicInMemoryCache>::get();
 }
 
 const QuicInMemoryCache::Response* QuicInMemoryCache::GetResponse(
-    const BalsaHeaders& request_headers) const {
-  ResponseMap::const_iterator it = responses_.find(GetKey(request_headers));
+    StringPiece host,
+    StringPiece path) const {
+  ResponseMap::const_iterator it = responses_.find(GetKey(host, path));
   if (it == responses_.end()) {
     return nullptr;
   }
   return it->second;
 }
 
-void QuicInMemoryCache::AddSimpleResponse(StringPiece method,
+void QuicInMemoryCache::AddSimpleResponse(StringPiece host,
                                           StringPiece path,
-                                          StringPiece version,
-                                          StringPiece response_code,
+                                          int 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);
+  BalsaHeaders response_headers;
+  response_headers.SetRequestFirstlineFromStringPieces(
+      "HTTP/1.1", base::IntToString(response_code), response_detail);
   response_headers.AppendHeader("content-length",
                                 base::IntToString(body.length()));
 
-  AddResponse(request_headers, response_headers, body);
+  AddResponse(host, path, response_headers, body);
 }
 
-void QuicInMemoryCache::AddResponse(const BalsaHeaders& request_headers,
+void QuicInMemoryCache::AddResponse(StringPiece host,
+                                    StringPiece path,
                                     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!";
-    return;
-  }
-  Response* new_response = new Response();
-  new_response->set_headers(response_headers);
-  new_response->set_body(response_body);
-  responses_[GetKey(request_headers)] = new_response;
+  AddResponseImpl(host, path, REGULAR_RESPONSE, response_headers,
+                  response_body);
 }
 
-void QuicInMemoryCache::AddSpecialResponse(StringPiece method,
+void QuicInMemoryCache::AddSpecialResponse(StringPiece host,
                                            StringPiece path,
-                                           StringPiece version,
                                            SpecialResponseType response_type) {
-  BalsaHeaders request_headers, response_headers;
-  request_headers.SetRequestFirstlineFromStringPieces(method,
-                                                      path,
-                                                      version);
-  AddResponse(request_headers, response_headers, "");
-  responses_[GetKey(request_headers)]->response_type_ = response_type;
+  AddResponseImpl(host, path, response_type, BalsaHeaders(), "");
 }
 
 QuicInMemoryCache::QuicInMemoryCache() {
   Initialize();
 }
 
 void QuicInMemoryCache::ResetForTests() {
   STLDeleteValues(&responses_);
   Initialize();
 }
 
 void QuicInMemoryCache::Initialize() {
   // If there's no defined cache dir, we have no initialization to do.
   if (FLAGS_quic_in_memory_cache_dir.empty()) {
     VLOG(1) << "No cache directory found. Skipping initialization.";
     return;
   }
   VLOG(1) << "Attempting to initialize QuicInMemoryCache from directory: "
           << FLAGS_quic_in_memory_cache_dir;
 
   FilePath directory(FLAGS_quic_in_memory_cache_dir);
   base::FileEnumerator file_list(directory,
                                  true,
                                  base::FileEnumerator::FILES);
 
-  FilePath file = file_list.Next();
-  while (!file.empty()) {
+  for (FilePath file = file_list.Next(); !file.empty();
+       file = file_list.Next()) {
     // Need to skip files in .svn directories
-    if (file.value().find("/.svn/") != std::string::npos) {
-      file = file_list.Next();
+    if (file.value().find("/.svn/") != string::npos) {
       continue;
     }
 
     BalsaHeaders request_headers, response_headers;
 
     string file_contents;
     base::ReadFileToString(file, &file_contents);
 
     // Frame HTTP.
     CachingBalsaVisitor caching_visitor;
@@ skipping 33 matching lines @@
         base.remove_prefix(7);
       }
     }
     int path_start = base.find_first_of('/');
     DCHECK_LT(0, 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);
-
-    VLOG(1) << "Inserting 'http://" << GetKey(request_headers)
-            << "' into QuicInMemoryCache.";
-
-    AddResponse(request_headers, response_headers, caching_visitor.body());
-
-    file = file_list.Next();
+    AddResponse(host, path, response_headers, caching_visitor.body());
   }
 }
 
 QuicInMemoryCache::~QuicInMemoryCache() {
   STLDeleteValues(&responses_);
 }
 
-string QuicInMemoryCache::GetKey(const BalsaHeaders& request_headers) const {
-  StringPiece uri = request_headers.request_uri();
-  if (uri.size() == 0) {
-    return "";
+void QuicInMemoryCache::AddResponseImpl(
+    StringPiece host,
+    StringPiece path,
+    SpecialResponseType response_type,
+    const BalsaHeaders& response_headers,
+    StringPiece response_body) {
+  string key = GetKey(host, path);
+  VLOG(1) << "Adding response for: " << key;
+  if (ContainsKey(responses_, key)) {
+    LOG(DFATAL) << "Response for '" << key << "' already exists!";
+    return;
   }
-  StringPiece host;
-  if (uri[0] == '/') {
-    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();
+  Response* new_response = new Response();
+  new_response->set_response_type(response_type);
+  new_response->set_headers(response_headers);
+  new_response->set_body(response_body);
+  responses_[key] = new_response;
+}
+
+string QuicInMemoryCache::GetKey(StringPiece host, StringPiece path) const {
+  return host.as_string() + path.as_string();
 }
 
 }  // namespace tools
 }  // namespace net