diff --git a/Core/FileLoaders/CachingFileLoader.cpp b/Core/FileLoaders/CachingFileLoader.cpp
index 597fafadcc..61a7459045 100644
--- a/Core/FileLoaders/CachingFileLoader.cpp
+++ b/Core/FileLoaders/CachingFileLoader.cpp
@@ -25,12 +25,12 @@
 
 // Takes ownership of backend.
 CachingFileLoader::CachingFileLoader(FileLoader *backend)
-	: backend_(backend) {
+	: ProxiedFileLoader(backend) {
 }
 
 void CachingFileLoader::Prepare() {
 	std::call_once(preparedFlag_, [this](){
-		filesize_ = backend_->FileSize();
+		filesize_ = ProxiedFileLoader::FileSize();
 		if (filesize_ > 0) {
 			InitCache();
 		}
@@ -41,27 +41,25 @@ CachingFileLoader::~CachingFileLoader() {
 	if (filesize_ > 0) {
 		ShutdownCache();
 	}
-	// Takes ownership.
-	delete backend_;
 }
 
 bool CachingFileLoader::Exists() {
 	if (exists_ == -1) {
-		exists_ = backend_->Exists() ? 1 : 0;
+		exists_ = ProxiedFileLoader::Exists() ? 1 : 0;
 	}
 	return exists_ == 1;
 }
 
 bool CachingFileLoader::ExistsFast() {
 	if (exists_ == -1) {
-		return backend_->ExistsFast();
+		return ProxiedFileLoader::ExistsFast();
 	}
 	return exists_ == 1;
 }
 
 bool CachingFileLoader::IsDirectory() {
 	if (isDirectory_ == -1) {
-		isDirectory_ = backend_->IsDirectory() ? 1 : 0;
+		isDirectory_ = ProxiedFileLoader::IsDirectory() ? 1 : 0;
 	}
 	return isDirectory_ == 1;
 }
@@ -71,10 +69,6 @@ s64 CachingFileLoader::FileSize() {
 	return filesize_;
 }
 
-std::string CachingFileLoader::Path() const {
-	return backend_->Path();
-}
-
 size_t CachingFileLoader::ReadAt(s64 absolutePos, size_t bytes, void *data, Flags flags) {
 	Prepare();
 	if (absolutePos >= filesize_) {
@@ -288,11 +282,3 @@ void CachingFileLoader::StartReadAhead(s64 pos) {
 	});
 	th.detach();
 }
-
-bool CachingFileLoader::IsRemote() {
-	return backend_->IsRemote();
-}
-
-void CachingFileLoader::Cancel() {
-	backend_->Cancel();
-}
diff --git a/Core/FileLoaders/CachingFileLoader.h b/Core/FileLoaders/CachingFileLoader.h
index 03d3aa726e..97fe0aa682 100644
--- a/Core/FileLoaders/CachingFileLoader.h
+++ b/Core/FileLoaders/CachingFileLoader.h
@@ -23,25 +23,21 @@
 #include "Common/CommonTypes.h"
 #include "Core/Loaders.h"
 
-class CachingFileLoader : public FileLoader {
+class CachingFileLoader : public ProxiedFileLoader {
 public:
 	CachingFileLoader(FileLoader *backend);
 	~CachingFileLoader() override;
 
-	bool IsRemote() override;
 	bool Exists() override;
 	bool ExistsFast() override;
 	bool IsDirectory() override;
 	s64 FileSize() override;
-	std::string Path() const override;
 
 	size_t ReadAt(s64 absolutePos, size_t bytes, size_t count, void *data, Flags flags = Flags::NONE) override {
 		return ReadAt(absolutePos, bytes * count, data, flags) / bytes;
 	}
 	size_t ReadAt(s64 absolutePos, size_t bytes, void *data, Flags flags = Flags::NONE) override;
 
-	void Cancel() override;
-
 private:
 	void Prepare();
 	void InitCache();
@@ -61,7 +57,6 @@ private:
 	};
 
 	s64 filesize_ = 0;
-	FileLoader *backend_;
 	int exists_ = -1;
 	int isDirectory_ = -1;
 	u64 generation_;
diff --git a/Core/FileLoaders/DiskCachingFileLoader.cpp b/Core/FileLoaders/DiskCachingFileLoader.cpp
index b098df4866..bb48ad3dbf 100644
--- a/Core/FileLoaders/DiskCachingFileLoader.cpp
+++ b/Core/FileLoaders/DiskCachingFileLoader.cpp
@@ -41,12 +41,12 @@ std::mutex DiskCachingFileLoader::cachesMutex_;
 
 // Takes ownership of backend.
 DiskCachingFileLoader::DiskCachingFileLoader(FileLoader *backend)
-	: backend_(backend) {
+	: ProxiedFileLoader(backend) {
 }
 
 void DiskCachingFileLoader::Prepare() {
 	std::call_once(preparedFlag_, [this]() {
-		filesize_ = backend_->FileSize();
+		filesize_ = ProxiedFileLoader::FileSize();
 		if (filesize_ > 0) {
 			InitCache();
 		}
@@ -57,13 +57,11 @@ DiskCachingFileLoader::~DiskCachingFileLoader() {
 	if (filesize_ > 0) {
 		ShutdownCache();
 	}
-	// Takes ownership.
-	delete backend_;
 }
 
 bool DiskCachingFileLoader::Exists() {
 	Prepare();
-	return backend_->Exists();
+	return ProxiedFileLoader::Exists();
 }
 
 bool DiskCachingFileLoader::ExistsFast() {
@@ -72,19 +70,11 @@ bool DiskCachingFileLoader::ExistsFast() {
 	return true;
 }
 
-bool DiskCachingFileLoader::IsDirectory() {
-	return backend_->IsDirectory();
-}
-
 s64 DiskCachingFileLoader::FileSize() {
 	Prepare();
 	return filesize_;
 }
 
-std::string DiskCachingFileLoader::Path() const {
-	return backend_->Path();
-}
-
 size_t DiskCachingFileLoader::ReadAt(s64 absolutePos, size_t bytes, void *data, Flags flags) {
 	Prepare();
 	size_t readSize;
@@ -115,14 +105,6 @@ size_t DiskCachingFileLoader::ReadAt(s64 absolutePos, size_t bytes, void *data,
 	return readSize;
 }
 
-bool DiskCachingFileLoader::IsRemote() {
-	return backend_->IsRemote();
-}
-
-void DiskCachingFileLoader::Cancel() {
-	backend_->Cancel();
-}
-
 std::vector<std::string> DiskCachingFileLoader::GetCachedPathsInUse() {
 	std::lock_guard<std::mutex> guard(cachesMutex_);
 
@@ -139,7 +121,7 @@ std::vector<std::string> DiskCachingFileLoader::GetCachedPathsInUse() {
 void DiskCachingFileLoader::InitCache() {
 	std::lock_guard<std::mutex> guard(cachesMutex_);
 
-	std::string path = backend_->Path();
+	std::string path = ProxiedFileLoader::Path();
 	auto &entry = caches_[path];
 	if (!entry) {
 		entry = new DiskCachingFileLoaderCache(path, filesize_);
@@ -155,7 +137,7 @@ void DiskCachingFileLoader::ShutdownCache() {
 	if (cache_->Release()) {
 		// If it ran out of counts, delete it.
 		delete cache_;
-		caches_.erase(backend_->Path());
+		caches_.erase(ProxiedFileLoader::Path());
 	}
 	cache_ = nullptr;
 }
diff --git a/Core/FileLoaders/DiskCachingFileLoader.h b/Core/FileLoaders/DiskCachingFileLoader.h
index e396ff5736..622ffb0f07 100644
--- a/Core/FileLoaders/DiskCachingFileLoader.h
+++ b/Core/FileLoaders/DiskCachingFileLoader.h
@@ -27,25 +27,20 @@
 
 class DiskCachingFileLoaderCache;
 
-class DiskCachingFileLoader : public FileLoader {
+class DiskCachingFileLoader : public ProxiedFileLoader {
 public:
 	DiskCachingFileLoader(FileLoader *backend);
 	~DiskCachingFileLoader() override;
 
-	bool IsRemote() override;
 	bool Exists() override;
 	bool ExistsFast() override;
-	bool IsDirectory() override;
 	s64 FileSize() override;
-	std::string Path() const override;
 
 	size_t ReadAt(s64 absolutePos, size_t bytes, size_t count, void *data, Flags flags = Flags::NONE) override {
 		return ReadAt(absolutePos, bytes * count, data, flags) / bytes;
 	}
 	size_t ReadAt(s64 absolutePos, size_t bytes, void *data, Flags flags = Flags::NONE) override;
 
-	void Cancel() override;
-
 	static std::vector<std::string> GetCachedPathsInUse();
 
 private:
@@ -55,7 +50,6 @@ private:
 
 	std::once_flag preparedFlag_;
 	s64 filesize_ = 0;
-	FileLoader *backend_;
 	DiskCachingFileLoaderCache *cache_ = nullptr;
 
 	// We don't support concurrent disk cache access (we use memory cached indexes.)
diff --git a/Core/FileLoaders/RamCachingFileLoader.cpp b/Core/FileLoaders/RamCachingFileLoader.cpp
index ccaa3c7bef..4b934cebdf 100644
--- a/Core/FileLoaders/RamCachingFileLoader.cpp
+++ b/Core/FileLoaders/RamCachingFileLoader.cpp
@@ -28,7 +28,7 @@
 
 // Takes ownership of backend.
 RamCachingFileLoader::RamCachingFileLoader(FileLoader *backend)
-	: backend_(backend) {
+	: ProxiedFileLoader(backend) {
 	filesize_ = backend->FileSize();
 	if (filesize_ > 0) {
 		InitCache();
@@ -39,27 +39,25 @@ RamCachingFileLoader::~RamCachingFileLoader() {
 	if (filesize_ > 0) {
 		ShutdownCache();
 	}
-	// Takes ownership.
-	delete backend_;
 }
 
 bool RamCachingFileLoader::Exists() {
 	if (exists_ == -1) {
-		exists_ = backend_->Exists() ? 1 : 0;
+		exists_ = ProxiedFileLoader::Exists() ? 1 : 0;
 	}
 	return exists_ == 1;
 }
 
 bool RamCachingFileLoader::ExistsFast() {
 	if (exists_ == -1) {
-		return backend_->ExistsFast();
+		return ProxiedFileLoader::ExistsFast();
 	}
 	return exists_ == 1;
 }
 
 bool RamCachingFileLoader::IsDirectory() {
 	if (isDirectory_ == -1) {
-		isDirectory_ = backend_->IsDirectory() ? 1 : 0;
+		isDirectory_ = ProxiedFileLoader::IsDirectory() ? 1 : 0;
 	}
 	return isDirectory_ == 1;
 }
@@ -68,10 +66,6 @@ s64 RamCachingFileLoader::FileSize() {
 	return filesize_;
 }
 
-std::string RamCachingFileLoader::Path() const {
-	return backend_->Path();
-}
-
 size_t RamCachingFileLoader::ReadAt(s64 absolutePos, size_t bytes, void *data, Flags flags) {
 	size_t readSize = 0;
 	if (cache_ == nullptr || (flags & Flags::HINT_UNCACHED) != 0) {
@@ -129,7 +123,7 @@ void RamCachingFileLoader::Cancel() {
 		aheadCancel_ = true;
 	}
 
-	backend_->Cancel();
+	ProxiedFileLoader::Cancel();
 }
 
 size_t RamCachingFileLoader::ReadFromCache(s64 pos, size_t bytes, void *data) {
@@ -270,7 +264,3 @@ u32 RamCachingFileLoader::NextAheadBlock() {
 
 	return 0xFFFFFFFF;
 }
-
-bool RamCachingFileLoader::IsRemote() {
-	return backend_->IsRemote();
-}
diff --git a/Core/FileLoaders/RamCachingFileLoader.h b/Core/FileLoaders/RamCachingFileLoader.h
index 624305155a..60ca2afc91 100644
--- a/Core/FileLoaders/RamCachingFileLoader.h
+++ b/Core/FileLoaders/RamCachingFileLoader.h
@@ -23,17 +23,15 @@
 #include "Common/CommonTypes.h"
 #include "Core/Loaders.h"
 
-class RamCachingFileLoader : public FileLoader {
+class RamCachingFileLoader : public ProxiedFileLoader {
 public:
 	RamCachingFileLoader(FileLoader *backend);
 	~RamCachingFileLoader() override;
 
-	bool IsRemote() override;
 	bool Exists() override;
 	bool ExistsFast() override;
 	bool IsDirectory() override;
 	s64 FileSize() override;
-	std::string Path() const override;
 
 	size_t ReadAt(s64 absolutePos, size_t bytes, size_t count, void *data, Flags flags = Flags::NONE) override {
 		return ReadAt(absolutePos, bytes * count, data, flags) / bytes;
@@ -59,7 +57,6 @@ private:
 	};
 
 	s64 filesize_ = 0;
-	FileLoader *backend_;
 	u8 *cache_ = nullptr;
 	int exists_ = -1;
 	int isDirectory_ = -1;
diff --git a/Core/FileLoaders/RetryingFileLoader.cpp b/Core/FileLoaders/RetryingFileLoader.cpp
index 4ce1da0261..b986d76bc9 100644
--- a/Core/FileLoaders/RetryingFileLoader.cpp
+++ b/Core/FileLoaders/RetryingFileLoader.cpp
@@ -19,47 +19,38 @@
 
 // Takes ownership of backend.
 RetryingFileLoader::RetryingFileLoader(FileLoader *backend)
-	: backend_(backend) {
-}
-
-RetryingFileLoader::~RetryingFileLoader() {
-	// Takes ownership.
-	delete backend_;
+	: ProxiedFileLoader(backend) {
 }
 
 bool RetryingFileLoader::Exists() {
-	if (!backend_->Exists()) {
+	if (!ProxiedFileLoader::Exists()) {
 		// Retry once, immediately.
-		return backend_->Exists();
+		return ProxiedFileLoader::Exists();
 	}
 	return true;
 }
 
 bool RetryingFileLoader::ExistsFast() {
-	if (!backend_->ExistsFast()) {
+	if (!ProxiedFileLoader::ExistsFast()) {
 		// Retry once, immediately.
-		return backend_->ExistsFast();
+		return ProxiedFileLoader::ExistsFast();
 	}
 	return true;
 }
 
 bool RetryingFileLoader::IsDirectory() {
 	// Can't tell if it's an error either way.
-	return backend_->IsDirectory();
+	return ProxiedFileLoader::IsDirectory();
 }
 
 s64 RetryingFileLoader::FileSize() {
-	s64 filesize = backend_->FileSize();
+	s64 filesize = ProxiedFileLoader::FileSize();
 	if (filesize == 0) {
-		return backend_->FileSize();
+		return ProxiedFileLoader::FileSize();
 	}
 	return filesize;
 }
 
-std::string RetryingFileLoader::Path() const {
-	return backend_->Path();
-}
-
 size_t RetryingFileLoader::ReadAt(s64 absolutePos, size_t bytes, void *data, Flags flags) {
 	size_t readSize = backend_->ReadAt(absolutePos, bytes, data, flags);
 
@@ -72,11 +63,3 @@ size_t RetryingFileLoader::ReadAt(s64 absolutePos, size_t bytes, void *data, Fla
 
 	return readSize;
 }
-
-bool RetryingFileLoader::IsRemote() {
-	return backend_->IsRemote();
-}
-
-void RetryingFileLoader::Cancel() {
-	backend_->Cancel();
-}
diff --git a/Core/FileLoaders/RetryingFileLoader.h b/Core/FileLoaders/RetryingFileLoader.h
index 5c8cb59292..c13edba926 100644
--- a/Core/FileLoaders/RetryingFileLoader.h
+++ b/Core/FileLoaders/RetryingFileLoader.h
@@ -20,29 +20,22 @@
 #include "Common/CommonTypes.h"
 #include "Core/Loaders.h"
 
-class RetryingFileLoader : public FileLoader {
+class RetryingFileLoader : public ProxiedFileLoader {
 public:
 	RetryingFileLoader(FileLoader *backend);
-	~RetryingFileLoader() override;
 
-	bool IsRemote() override;
 	bool Exists() override;
 	bool ExistsFast() override;
 	bool IsDirectory() override;
 	s64 FileSize() override;
-	std::string Path() const override;
 
 	size_t ReadAt(s64 absolutePos, size_t bytes, size_t count, void *data, Flags flags = Flags::NONE) override {
 		return ReadAt(absolutePos, bytes * count, data, flags) / bytes;
 	}
 	size_t ReadAt(s64 absolutePos, size_t bytes, void *data, Flags flags = Flags::NONE) override;
 
-	void Cancel() override;
-
 private:
 	enum {
 		MAX_RETRIES = 3,
 	};
-
-	FileLoader *backend_;
 };
diff --git a/Core/Loaders.h b/Core/Loaders.h
index f0e83adab4..216cc0fcd9 100644
--- a/Core/Loaders.h
+++ b/Core/Loaders.h
@@ -95,6 +95,41 @@ public:
 	}
 };
 
+class ProxiedFileLoader : public FileLoader {
+public:
+	ProxiedFileLoader(FileLoader *backend) : backend_(backend) {
+	}
+	~ProxiedFileLoader() override {
+		// Takes ownership.
+		delete backend_;
+	}
+
+	bool IsRemote() override {
+		return backend_->IsRemote();
+	}
+	bool Exists() override {
+		return backend_->Exists();
+	}
+	bool ExistsFast() override {
+		return backend_->ExistsFast();
+	}
+	bool IsDirectory() override {
+		return backend_->IsDirectory();
+	}
+	s64 FileSize() override {
+		return backend_->FileSize();
+	}
+	std::string Path() const override {
+		return backend_->Path();
+	}
+	void Cancel() override {
+		backend_->Cancel();
+	}
+
+protected:
+	FileLoader *backend_;
+};
+
 inline u32 operator & (const FileLoader::Flags &a, const FileLoader::Flags &b) {
 	return (u32)a & (u32)b;
 }