Provide a default implementation of quiche_file_utils.
This also adds support for building on Windows, at least far enough to get the file_utils test to build.
PiperOrigin-RevId: 382741424
diff --git a/common/platform/api/quiche_file_utils.cc b/common/platform/api/quiche_file_utils.cc
new file mode 100644
index 0000000..fc0c189
--- /dev/null
+++ b/common/platform/api/quiche_file_utils.cc
@@ -0,0 +1,51 @@
+#include "common/platform/api/quiche_file_utils.h"
+
+#include "quiche_platform_impl/quiche_file_utils_impl.h"
+
+namespace quiche {
+
+std::string JoinPath(absl::string_view a, absl::string_view b) {
+ return JoinPathImpl(a, b);
+}
+
+absl::optional<std::string> ReadFileContents(absl::string_view file) {
+ return ReadFileContentsImpl(file);
+}
+
+bool EnumerateDirectory(absl::string_view path,
+ std::vector<std::string>& directories,
+ std::vector<std::string>& files) {
+ return EnumerateDirectoryImpl(path, directories, files);
+}
+
+bool EnumerateDirectoryRecursivelyInner(absl::string_view path,
+ int recursion_limit,
+ std::vector<std::string>& files) {
+ if (recursion_limit < 0) {
+ return false;
+ }
+
+ std::vector<std::string> local_files;
+ std::vector<std::string> directories;
+ if (!EnumerateDirectory(path, directories, local_files)) {
+ return false;
+ }
+ for (const std::string& directory : directories) {
+ if (!EnumerateDirectoryRecursivelyInner(JoinPath(path, directory),
+ recursion_limit - 1, files)) {
+ return false;
+ }
+ }
+ for (const std::string& file : local_files) {
+ files.push_back(JoinPath(path, file));
+ }
+ return true;
+}
+
+bool EnumerateDirectoryRecursively(absl::string_view path,
+ std::vector<std::string>& files) {
+ constexpr int kRecursionLimit = 20;
+ return EnumerateDirectoryRecursivelyInner(path, kRecursionLimit, files);
+}
+
+} // namespace quiche
diff --git a/common/platform/api/quiche_file_utils.h b/common/platform/api/quiche_file_utils.h
new file mode 100644
index 0000000..47723d1
--- /dev/null
+++ b/common/platform/api/quiche_file_utils.h
@@ -0,0 +1,40 @@
+// Copyright 2021 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.
+
+// This header contains basic filesystem functions for use in unit tests and CLI
+// tools. Note that those are not 100% suitable for production use, as in, they
+// might be prone to race conditions and not always handle non-ASCII filenames
+// correctly.
+#ifndef QUICHE_COMMON_PLATFORM_API_QUICHE_FILE_UTILS_H_
+#define QUICHE_COMMON_PLATFORM_API_QUICHE_FILE_UTILS_H_
+
+#include <string>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+namespace quiche {
+
+// Join two paths in a platform-specific way. Returns |a| if |b| is empty, and
+// vice versa.
+std::string JoinPath(absl::string_view a, absl::string_view b);
+
+// Reads the entire file into the memory.
+absl::optional<std::string> ReadFileContents(absl::string_view file);
+
+// Lists all files and directories in the directory specified by |path|. Returns
+// true on success, false on failure.
+bool EnumerateDirectory(absl::string_view path,
+ std::vector<std::string>& directories,
+ std::vector<std::string>& files);
+
+// Recursively enumerates all of the files in the directory and all of the
+// internal subdirectories. Has a fairly small recursion limit.
+bool EnumerateDirectoryRecursively(absl::string_view path,
+ std::vector<std::string>& files);
+
+} // namespace quiche
+
+#endif // QUICHE_COMMON_PLATFORM_API_QUICHE_FILE_UTILS_H_
diff --git a/common/platform/api/quiche_file_utils_test.cc b/common/platform/api/quiche_file_utils_test.cc
new file mode 100644
index 0000000..ddf1a40
--- /dev/null
+++ b/common/platform/api/quiche_file_utils_test.cc
@@ -0,0 +1,86 @@
+#include "common/platform/api/quiche_file_utils.h"
+
+#include <vector>
+
+#include "absl/algorithm/container.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/strip.h"
+#include "absl/types/optional.h"
+#include "common/platform/api/quiche_test.h"
+
+namespace quiche {
+namespace test {
+namespace {
+
+using testing::UnorderedElementsAre;
+using testing::UnorderedElementsAreArray;
+
+TEST(QuicheFileUtilsTest, ReadFileContents) {
+ std::string path = absl::StrCat(QuicheGetCommonSourcePath(),
+ "/platform/api/testdir/testfile");
+ absl::optional<std::string> contents = ReadFileContents(path);
+ ASSERT_TRUE(contents.has_value());
+ EXPECT_EQ(*contents, "This is a test file.");
+}
+
+TEST(QuicheFileUtilsTest, ReadFileContentsFileNotFound) {
+ std::string path =
+ absl::StrCat(QuicheGetCommonSourcePath(),
+ "/platform/api/testdir/file-that-does-not-exist");
+ absl::optional<std::string> contents = ReadFileContents(path);
+ EXPECT_FALSE(contents.has_value());
+}
+
+TEST(QuicheFileUtilsTest, EnumerateDirectory) {
+ std::string path =
+ absl::StrCat(QuicheGetCommonSourcePath(), "/platform/api/testdir");
+ std::vector<std::string> dirs;
+ std::vector<std::string> files;
+ bool success = EnumerateDirectory(path, dirs, files);
+ EXPECT_TRUE(success);
+ EXPECT_THAT(files, UnorderedElementsAre("testfile", "README.md"));
+ EXPECT_THAT(dirs, UnorderedElementsAre("a"));
+}
+
+TEST(QuicheFileUtilsTest, EnumerateDirectoryNoSuchDirectory) {
+ std::string path = absl::StrCat(QuicheGetCommonSourcePath(),
+ "/platform/api/testdir/no-such-directory");
+ std::vector<std::string> dirs;
+ std::vector<std::string> files;
+ bool success = EnumerateDirectory(path, dirs, files);
+ EXPECT_FALSE(success);
+}
+
+TEST(QuicheFileUtilsTest, EnumerateDirectoryNotADirectory) {
+ std::string path = absl::StrCat(QuicheGetCommonSourcePath(),
+ "/platform/api/testdir/testfile");
+ std::vector<std::string> dirs;
+ std::vector<std::string> files;
+ bool success = EnumerateDirectory(path, dirs, files);
+ EXPECT_FALSE(success);
+}
+
+TEST(QuicheFileUtilsTest, EnumerateDirectoryRecursively) {
+ std::vector<std::string> expected_paths = {"a/b/c/d/e", "a/subdir/testfile",
+ "a/z", "testfile", "README.md"};
+
+ std::string root_path =
+ absl::StrCat(QuicheGetCommonSourcePath(), "/platform/api/testdir");
+ for (std::string& path : expected_paths) {
+ // For Windows, use Windows path separators.
+ if (JoinPath("a", "b") == "a\\b") {
+ absl::c_replace(path, '/', '\\');
+ }
+
+ path = JoinPath(root_path, path);
+ }
+
+ std::vector<std::string> files;
+ bool success = EnumerateDirectoryRecursively(root_path, files);
+ EXPECT_TRUE(success);
+ EXPECT_THAT(files, UnorderedElementsAreArray(expected_paths));
+}
+
+} // namespace
+} // namespace test
+} // namespace quiche
diff --git a/common/platform/api/quiche_test.h b/common/platform/api/quiche_test.h
index 1af25df..efec638 100644
--- a/common/platform/api/quiche_test.h
+++ b/common/platform/api/quiche_test.h
@@ -12,6 +12,18 @@
template <class T>
using QuicheTestWithParam = quiche::test::QuicheTestWithParamImpl<T>;
+namespace quiche {
+namespace test {
+
+// Returns the path to quiche/common directory where the test data could be
+// located.
+inline std::string QuicheGetCommonSourcePath() {
+ return QuicheGetCommonSourcePathImpl();
+}
+
+} // namespace test
+} // namespace quiche
+
#define EXPECT_QUICHE_DEBUG_DEATH(condition, message) \
EXPECT_QUICHE_DEBUG_DEATH_IMPL(condition, message)
