WIP

quic/tools/quic_memory_cache_backend.cc

diff --git a/quic/tools/quic_memory_cache_backend.cc b/quic/tools/quic_memory_cache_backend.cc
index 38d25e5..206d2c5 100644
--- a/quic/tools/quic_memory_cache_backend.cc
+++ b/quic/tools/quic_memory_cache_backend.cc
@@ -236,23 +236,31 @@
 
 bool QuicMemoryCacheBackend::InitializeBackend(
     const std::string& cache_directory) {
+  LOG(INFO) << __FUNCTION__;
   if (cache_directory.empty()) {
     QUIC_BUG << "cache_directory must not be empty.";
     return false;
   }
-  QUIC_LOG(INFO)
+  LOG(INFO)
       << "Attempting to initialize QuicMemoryCacheBackend from directory: "
       << cache_directory;
   std::vector<std::string> files = ReadFileContents(cache_directory);
+  LOG(INFO) << "files.size():" << files.size();
   std::list<std::unique_ptr<ResourceFile>> resource_files;
   for (const auto& filename : files) {
     std::unique_ptr<ResourceFile> resource_file(new ResourceFile(filename));
 
     // Tease apart filename into host and path.
-    QuicStringPiece base(resource_file->file_name());
-    base.remove_prefix(cache_directory.length());
+    std::string base(resource_file->file_name());
+    for (size_t i = 0; i < base.length(); ++i) {
+      if (base[i] == '\\') {
+        base[i] = '/';
+      }
+    }
+    LOG(INFO) << base;
+    base.erase(0, cache_directory.length());
     if (base[0] == '/') {
-      base.remove_prefix(1);
+      base.erase(0, 1);
     }
 
     resource_file->SetHostPathFromBase(base);

quic/tools/quic_memory_cache_backend_test.cc

diff --git a/quic/tools/quic_memory_cache_backend_test.cc b/quic/tools/quic_memory_cache_backend_test.cc
index 01ac334..90a76d8 100644
--- a/quic/tools/quic_memory_cache_backend_test.cc
+++ b/quic/tools/quic_memory_cache_backend_test.cc
@@ -10,6 +10,10 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
 #include "net/third_party/quiche/src/quic/tools/quic_backend_response.h"
 
+#include "base/files/scoped_temp_dir.h"
+#include "base/files/file_enumerator.h"
+#include "base/files/file_util.h"
+
 namespace quic {
 namespace test {
 
@@ -18,6 +22,38 @@
 typedef QuicBackendResponse::ServerPushInfo ServerPushInfo;
 }  // namespace
 
+using testing::ElementsAre;
+using testing::IsEmpty;
+using base::FilePath;
+using base::ScopedTempDir;
+using base::FileEnumerator;
+using base::circular_deque;
+
+const FilePath::StringType kEmptyPattern;
+
+const std::vector<FileEnumerator::FolderSearchPolicy> kFolderSearchPolicies{
+    FileEnumerator::FolderSearchPolicy::MATCH_ONLY,
+    FileEnumerator::FolderSearchPolicy::ALL};
+
+circular_deque<FilePath> RunEnumerator(
+    const FilePath& root_path,
+    bool recursive,
+    int file_type,
+    const FilePath::StringType& pattern,
+    FileEnumerator::FolderSearchPolicy folder_search_policy) {
+  circular_deque<FilePath> rv;
+  FileEnumerator enumerator(root_path, recursive, file_type, pattern,
+                            folder_search_policy);
+  for (auto file = enumerator.Next(); !file.empty(); file = enumerator.Next())
+    rv.emplace_back(std::move(file));
+  return rv;
+}
+
+bool CreateDummyFile(const FilePath& path) {
+  return WriteFile(path, "42", sizeof("42")) == sizeof("42");
+}
+
+
 class QuicMemoryCacheBackendTest : public QuicTest {
  protected:
   void CreateRequest(std::string host,
@@ -34,6 +70,49 @@
   QuicMemoryCacheBackend cache_;
 };
 
+TEST(FileEnumerator, FileInSubfolder) {
+  FilePath directory(FilePath::FromUTF8Unsafe(QuicGetTestMemoryCachePath()));
+
+  for (auto policy : kFolderSearchPolicies) {
+    auto files = RunEnumerator(directory, true, FileEnumerator::FILES,
+                               kEmptyPattern, policy);
+    EXPECT_FALSE(files.empty());
+
+    files = RunEnumerator(directory, false, FileEnumerator::FILES,
+                          kEmptyPattern, policy);
+    EXPECT_THAT(files, IsEmpty());
+  }
+
+  FilePath directory2(FilePath::FromUTF8Unsafe(QuicGetTestMemoryCachePath() + "/test.example.com"));
+
+  for (auto policy : kFolderSearchPolicies) {
+    auto files = RunEnumerator(directory2, true, FileEnumerator::FILES,
+                               kEmptyPattern, policy);
+    EXPECT_FALSE(files.empty());
+  }
+}
+
+TEST(FileEnumerator, FileInSubfolderReal) {
+  ScopedTempDir temp_dir;
+  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
+
+  const FilePath subdir = temp_dir.GetPath().AppendASCII("subdir");
+  ASSERT_TRUE(CreateDirectory(subdir));
+
+  const FilePath file = subdir.AppendASCII("test.txt");
+  ASSERT_TRUE(CreateDummyFile(file));
+
+  for (auto policy : kFolderSearchPolicies) {
+    auto files = RunEnumerator(temp_dir.GetPath(), true, FileEnumerator::FILES,
+                               kEmptyPattern, policy);
+    EXPECT_THAT(files, ElementsAre(file));
+
+    files = RunEnumerator(temp_dir.GetPath(), false, FileEnumerator::FILES,
+                          kEmptyPattern, policy);
+    EXPECT_THAT(files, IsEmpty());
+  }
+}
+
 TEST_F(QuicMemoryCacheBackendTest, GetResponseNoMatch) {
   const Response* response =
       cache_.GetResponse("mail.google.com", "/index.html");