Cleanup of QuicInMemoryCache to sync with internal version.

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/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
+#include "net/tools/flip_server/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 {
 namespace tools {
 
-std::string FLAGS_quic_in_memory_cache_dir = "/tmp/quic-data";
+std::string FLAGS_quic_in_memory_cache_dir = "";
 
 namespace {
 
 // BalsaVisitor implementation (glue) which caches response bodies.
-class CachingBalsaVisitor : public BalsaVisitorInterface {
+class CachingBalsaVisitor : public NoOpBalsaVisitor {
  public:
   CachingBalsaVisitor() : done_framing_(false) {}
   virtual void ProcessBodyData(const char* input, size_t size) OVERRIDE {
     AppendToBody(input, size);
   }
-  virtual void ProcessTrailers(const BalsaHeaders& trailer) {
-    LOG(DFATAL) << "Trailers not supported.";
-  }
   virtual void MessageDone() OVERRIDE {
     done_framing_ = true;
   }
   virtual void HandleHeaderError(BalsaFrame* framer) OVERRIDE {
     UnhandledError();
   }
   virtual void HandleHeaderWarning(BalsaFrame* framer) OVERRIDE {
     UnhandledError();
   }
-  virtual void HandleTrailerError(BalsaFrame* framer) { UnhandledError(); }
-  virtual void HandleTrailerWarning(BalsaFrame* framer) { UnhandledError(); }
   virtual void HandleChunkingError(BalsaFrame* framer) OVERRIDE {
     UnhandledError();
   }
   virtual void HandleBodyError(BalsaFrame* framer) OVERRIDE {
     UnhandledError();
   }
   void UnhandledError() {
     LOG(DFATAL) << "Unhandled error framing HTTP.";
   }
-  virtual void ProcessBodyInput(const char*, size_t) OVERRIDE {}
-  virtual void ProcessHeaderInput(const char*, size_t) OVERRIDE {}
-  virtual void ProcessTrailerInput(const char*, size_t) OVERRIDE {}
-  virtual void ProcessHeaders(const net::BalsaHeaders&) OVERRIDE {}
-  virtual void ProcessRequestFirstLine(
-      const char*, size_t, const char*, size_t,
-      const char*, size_t, const char*, size_t) OVERRIDE {}
-  virtual void ProcessResponseFirstLine(
-      const char*, size_t, const char*,
-      size_t, const char*, size_t, const char*, size_t) OVERRIDE {}
-  virtual void ProcessChunkLength(size_t) OVERRIDE {}
-  virtual void ProcessChunkExtensions(const char*, size_t) OVERRIDE {}
-  virtual void HeaderDone() OVERRIDE {}
-
   void AppendToBody(const char* input, size_t size) {
     body_.append(input, size);
   }
   bool done_framing() const { return done_framing_; }
   const string& body() const { return body_; }
 
  private:
   bool done_framing_;
   string body_;
 };
 
 }  // 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));
   if (it == responses_.end()) {
     return NULL;
   }
   return it->second;
 }
 
-void QuicInMemoryCache::AddOrVerifyResponse(StringPiece method,
-                                            StringPiece path,
-                                            StringPiece version,
-                                            StringPiece response_code,
-                                            StringPiece response_detail,
-                                            StringPiece body) {
+void QuicInMemoryCache::AddSimpleResponse(StringPiece method,
+                                          StringPiece path,
+                                          StringPiece version,
+                                          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()));
 
-  // Check if response already exists and matches.
-  const QuicInMemoryCache::Response* cached_response =
-      GetResponse(request_headers);
-  if (cached_response == NULL) {
-    AddResponse(request_headers, response_headers, body);
-    return;
-  }
-  string cached_response_headers_str, response_headers_str;
-  cached_response->headers().DumpToString(&cached_response_headers_str);
-  response_headers.DumpToString(&response_headers_str);
-  CHECK_EQ(cached_response_headers_str, response_headers_str);
-  CHECK_EQ(cached_response->body(), body);
+  AddResponse(request_headers, response_headers, body);
 }
 
 void QuicInMemoryCache::AddResponse(const BalsaHeaders& request_headers,
                                     const BalsaHeaders& response_headers,
                                     StringPiece response_body) {
   LOG(INFO) << "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;
 }
 
+QuicInMemoryCache::QuicInMemoryCache() {
+  Initialize();
+}
+
 void QuicInMemoryCache::ResetForTests() {
   STLDeleteValues(&responses_);
   Initialize();
 }
 
-QuicInMemoryCache::QuicInMemoryCache() {
-  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()) {
     LOG(WARNING) << "No cache directory found. Skipping initialization.";
     return;
   }
   LOG(INFO) << "Attempting to initialize QuicInMemoryCache from directory: "
             << FLAGS_quic_in_memory_cache_dir;
 
   FilePath directory(FLAGS_quic_in_memory_cache_dir);
@@ skipping 88 matching lines @@
   } 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 tools
 }  // namespace net