Remove //net (except for Android test stuff) and sdch

net/tools/quic/quic_in_memory_cache.cc

Index: net/tools/quic/quic_in_memory_cache.cc
diff --git a/net/tools/quic/quic_in_memory_cache.cc b/net/tools/quic/quic_in_memory_cache.cc
deleted file mode 100644
index cb96335819780352f448c80e26e43086ff3a9d32..0000000000000000000000000000000000000000
--- a/net/tools/quic/quic_in_memory_cache.cc
+++ /dev/null
@@ -1,232 +0,0 @@
-// 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;
-
-// 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 = "";
-
-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);
-  }
-  void MessageDone() override { done_framing_ = true; }
-  void HandleHeaderError(BalsaFrame* framer) override { UnhandledError(); }
-  void HandleHeaderWarning(BalsaFrame* framer) override { UnhandledError(); }
-  void HandleChunkingError(BalsaFrame* framer) override { UnhandledError(); }
-  void HandleBodyError(BalsaFrame* framer) override { UnhandledError(); }
-  void UnhandledError() {
-    LOG(DFATAL) << "Unhandled error framing HTTP.";
-  }
-  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 nullptr;
-  }
-  return it->second;
-}
-
-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()));
-
-  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!";
-    return;
-  }
-  Response* new_response = new Response();
-  new_response->set_headers(response_headers);
-  new_response->set_body(response_body);
-  responses_[GetKey(request_headers)] = new_response;
-}
-
-void QuicInMemoryCache::AddSpecialResponse(StringPiece method,
-                                           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;
-}
-
-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()) {
-    // Need to skip files in .svn directories
-    if (file.value().find("/.svn/") != std::string::npos) {
-      file = file_list.Next();
-      continue;
-    }
-
-    BalsaHeaders request_headers, response_headers;
-
-    string file_contents;
-    base::ReadFileToString(file, &file_contents);
-
-    // Frame HTTP.
-    CachingBalsaVisitor caching_visitor;
-    BalsaFrame framer;
-    framer.set_balsa_headers(&response_headers);
-    framer.set_balsa_visitor(&caching_visitor);
-    size_t processed = 0;
-    while (processed < file_contents.length() &&
-           !caching_visitor.done_framing()) {
-      processed += framer.ProcessInput(file_contents.c_str() + processed,
-                                       file_contents.length() - processed);
-    }
-
-    if (!caching_visitor.done_framing()) {
-      LOG(DFATAL) << "Did not frame entire message from file: " << file.value()
-                  << " (" << processed << " of " << file_contents.length()
-                  << " bytes).";
-    }
-    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.value();
-    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);
-    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();
-  }
-}
-
-QuicInMemoryCache::~QuicInMemoryCache() {
-  STLDeleteValues(&responses_);
-}
-
-string QuicInMemoryCache::GetKey(const BalsaHeaders& request_headers) const {
-  StringPiece uri = request_headers.request_uri();
-  if (uri.size() == 0) {
-    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();
-}
-
-}  // namespace tools
-}  // namespace net