Making stateless file IO platform-agnostic.

src/xenia/base/filesystem.h

@@ -11,14 +11,12 @@
 #define XENIA_BASE_FILESYSTEM_H_
 
 #include <iterator>
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "xenia/base/string.h"
 
-// TOODO(benvanik): remove windows headers.
-#undef DeleteFile
-
 namespace xe {
 namespace filesystem {
 
@@ -33,6 +31,50 @@ bool IsFolder(const std::wstring& path);
 FILE* OpenFile(const std::wstring& path, const char* mode);
 bool DeleteFile(const std::wstring& path);
 
+struct FileAccess {
+  // Implies kFileReadData.
+  static const uint32_t kGenericRead = 0x80000000;
+  // Implies kFileWriteData.
+  static const uint32_t kGenericWrite = 0x40000000;
+  static const uint32_t kGenericExecute = 0x20000000;
+  static const uint32_t kGenericAll = 0x10000000;
+  static const uint32_t kFileReadData = 0x00000001;
+  static const uint32_t kFileWriteData = 0x00000002;
+  static const uint32_t kFileAppendData = 0x00000004;
+};
+
+class FileHandle {
+ public:
+  // Opens the file, failing if it doesn't exist.
+  // The desired_access bitmask denotes the permissions on the file.
+  static std::unique_ptr<FileHandle> OpenExisting(std::wstring path,
+                                                  uint32_t desired_access);
+
+  virtual ~FileHandle() = default;
+
+  std::wstring path() const { return path_; }
+
+  // Reads the requested number of bytes from the file starting at the given
+  // offset. The total number of bytes read is returned only if the complete
+  // read succeeds.
+  virtual bool Read(size_t file_offset, void* buffer, size_t buffer_length,
+                    size_t* out_bytes_read) = 0;
+
+  // Writes the given buffer to the file starting at the given offset.
+  // The total number of bytes written is returned only if the complete
+  // write succeeds.
+  virtual bool Write(size_t file_offset, const void* buffer,
+                     size_t buffer_length, size_t* out_bytes_written) = 0;
+
+  // Flushes any pending write buffers to the underlying filesystem.
+  virtual void Flush() = 0;
+
+ protected:
+  FileHandle(std::wstring path) : path_(std::move(path)) {}
+
+  std::wstring path_;
+};
+
 struct FileInfo {
   enum class Type {
     kFile,

src/xenia/base/filesystem_win.cc

@@ -56,6 +56,89 @@ bool DeleteFile(const std::wstring& path) {
   return DeleteFileW(path.c_str()) ? true : false;
 }
 
+class Win32FileHandle : public FileHandle {
+ public:
+  Win32FileHandle(std::wstring path, HANDLE handle)
+      : FileHandle(std::move(path)), handle_(handle) {}
+  ~Win32FileHandle() override {
+    CloseHandle(handle_);
+    handle_ = nullptr;
+  }
+  bool Read(size_t file_offset, void* buffer, size_t buffer_length,
+            size_t* out_bytes_read) override {
+    *out_bytes_read = 0;
+    OVERLAPPED overlapped;
+    overlapped.Pointer = (PVOID)file_offset;
+    overlapped.hEvent = NULL;
+    DWORD bytes_read = 0;
+    BOOL read = ReadFile(handle_, buffer, (DWORD)buffer_length, &bytes_read,
+                         &overlapped);
+    if (read) {
+      *out_bytes_read = bytes_read;
+      return true;
+    } else {
+      return false;
+    }
+  }
+  bool Write(size_t file_offset, const void* buffer, size_t buffer_length,
+             size_t* out_bytes_written) override {
+    *out_bytes_written = 0;
+    OVERLAPPED overlapped;
+    overlapped.Pointer = (PVOID)file_offset;
+    overlapped.hEvent = NULL;
+    DWORD bytes_written = 0;
+    BOOL wrote = WriteFile(handle_, buffer, (DWORD)buffer_length,
+                           &bytes_written, &overlapped);
+    if (wrote) {
+      *out_bytes_written = bytes_written;
+      return true;
+    } else {
+      return false;
+    }
+  }
+  void Flush() override { FlushFileBuffers(handle_); }
+
+ private:
+  HANDLE handle_ = nullptr;
+};
+
+std::unique_ptr<FileHandle> FileHandle::OpenExisting(std::wstring path,
+                                                     uint32_t desired_access) {
+  DWORD open_access = 0;
+  if (desired_access & FileAccess::kGenericRead) {
+    open_access |= GENERIC_READ;
+  }
+  if (desired_access & FileAccess::kGenericWrite) {
+    open_access |= GENERIC_WRITE;
+  }
+  if (desired_access & FileAccess::kGenericExecute) {
+    open_access |= GENERIC_EXECUTE;
+  }
+  if (desired_access & FileAccess::kGenericAll) {
+    open_access |= GENERIC_ALL;
+  }
+  if (desired_access & FileAccess::kFileReadData) {
+    open_access |= FILE_READ_DATA;
+  }
+  if (desired_access & FileAccess::kFileWriteData) {
+    open_access |= FILE_WRITE_DATA;
+  }
+  if (desired_access & FileAccess::kFileAppendData) {
+    open_access |= FILE_APPEND_DATA;
+  }
+  DWORD share_mode = FILE_SHARE_READ;
+  // We assume we've already created the file in the caller.
+  DWORD creation_disposition = OPEN_EXISTING;
+  HANDLE handle =
+      CreateFileW(path.c_str(), open_access, share_mode, NULL,
+                  creation_disposition, FILE_FLAG_BACKUP_SEMANTICS, NULL);
+  if (handle == INVALID_HANDLE_VALUE) {
+    // TODO(benvanik): pick correct response.
+    return nullptr;
+  }
+  return std::make_unique<Win32FileHandle>(path, handle);
+}
+
 #define COMBINE_TIME(t) (((uint64_t)t.dwHighDateTime << 32) | t.dwLowDateTime)
 
 bool GetInfo(const std::wstring& path, FileInfo* out_info) {