--- a/dom/events/DataTransferItem.cpp
+++ b/dom/events/DataTransferItem.cpp
@@ -6,19 +6,19 @@
 #include "DataTransferItem.h"
 #include "DataTransferItemList.h"
 
 #include "mozilla/ContentEvents.h"
 #include "mozilla/EventForwards.h"
 #include "mozilla/dom/DataTransferItemBinding.h"
 #include "mozilla/dom/Directory.h"
 #include "mozilla/dom/DirectoryEntry.h"
-#include "mozilla/dom/DOMFileSystem.h"
 #include "mozilla/dom/Event.h"
 #include "mozilla/dom/FileEntry.h"
+#include "mozilla/dom/FileSystem.h"
 #include "nsIClipboard.h"
 #include "nsISupportsPrimitives.h"
 #include "nsNetUtil.h"
 #include "nsQueryObject.h"
 #include "nsContentUtils.h"
 #include "nsVariant.h"
 
 namespace {
@@ -303,17 +303,17 @@ DataTransferItem::GetAsEntry(ErrorResult
       global = event->InternalDOMEvent()->GetParentObject();
     }
   }
 
   if (!global) {
     return nullptr;
   }
 
-  RefPtr<DOMFileSystem> fs = DOMFileSystem::Create(global);
+  RefPtr<FileSystem> fs = FileSystem::Create(global);
   RefPtr<Entry> entry;
   BlobImpl* impl = file->Impl();
   MOZ_ASSERT(impl);
 
   if (impl->IsDirectory()) {
     nsAutoString fullpath;
     impl->GetMozFullPathInternal(fullpath, aRv);
     if (aRv.Failed()) {

--- a/dom/filesystem/compat/CallbackRunnables.cpp
+++ b/dom/filesystem/compat/CallbackRunnables.cpp
@@ -68,17 +68,17 @@ NS_IMETHODIMP
 EmptyEntriesCallbackRunnable::Run()
 {
   Sequence<OwningNonNull<Entry>> sequence;
   mCallback->HandleEvent(sequence);
   return NS_OK;
 }
 
 GetEntryHelper::GetEntryHelper(nsIGlobalObject* aGlobalObject,
-                               DOMFileSystem* aFileSystem,
+                               FileSystem* aFileSystem,
                                EntryCallback* aSuccessCallback,
                                ErrorCallback* aErrorCallback,
                                DirectoryEntry::GetInternalType aType)
   : mGlobal(aGlobalObject)
   , mFileSystem(aFileSystem)
   , mSuccessCallback(aSuccessCallback)
   , mErrorCallback(aErrorCallback)
   , mType(aType)

--- a/dom/filesystem/compat/CallbackRunnables.h
+++ b/dom/filesystem/compat/CallbackRunnables.h
@@ -59,17 +59,17 @@ private:
 };
 
 class GetEntryHelper final : public PromiseNativeHandler
 {
 public:
   NS_DECL_ISUPPORTS
 
   GetEntryHelper(nsIGlobalObject* aGlobalObject,
-                 DOMFileSystem* aFileSystem,
+                 FileSystem* aFileSystem,
                  EntryCallback* aSuccessCallback,
                  ErrorCallback* aErrorCallback,
                  DirectoryEntry::GetInternalType aType);
 
   virtual void
   ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override;
 
   virtual void
@@ -77,17 +77,17 @@ public:
 
 private:
   ~GetEntryHelper();
 
   void
   Error(nsresult aError);
 
   nsCOMPtr<nsIGlobalObject> mGlobal;
-  RefPtr<DOMFileSystem> mFileSystem;
+  RefPtr<FileSystem> mFileSystem;
   RefPtr<EntryCallback> mSuccessCallback;
   RefPtr<ErrorCallback> mErrorCallback;
   DirectoryEntry::GetInternalType mType;
 };
 
 class ErrorCallbackHelper
 {
 public:

--- a/dom/filesystem/compat/DirectoryEntry.cpp
+++ b/dom/filesystem/compat/DirectoryEntry.cpp
@@ -18,17 +18,17 @@ NS_IMPL_CYCLE_COLLECTION_INHERITED(Direc
 NS_IMPL_ADDREF_INHERITED(DirectoryEntry, Entry)
 NS_IMPL_RELEASE_INHERITED(DirectoryEntry, Entry)
 
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(DirectoryEntry)
 NS_INTERFACE_MAP_END_INHERITING(Entry)
 
 DirectoryEntry::DirectoryEntry(nsIGlobalObject* aGlobal,
                                Directory* aDirectory,
-                               DOMFileSystem* aFileSystem)
+                               FileSystem* aFileSystem)
   : Entry(aGlobal, aFileSystem)
   , mDirectory(aDirectory)
 {
   MOZ_ASSERT(aGlobal);
 }
 
 DirectoryEntry::~DirectoryEntry()
 {}

--- a/dom/filesystem/compat/DirectoryEntry.h
+++ b/dom/filesystem/compat/DirectoryEntry.h
@@ -3,31 +3,31 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef mozilla_dom_DirectoryEntry_h
 #define mozilla_dom_DirectoryEntry_h
 
 #include "mozilla/dom/Entry.h"
-#include "mozilla/dom/DOMFileSystemBinding.h"
+#include "mozilla/dom/FileSystemBinding.h"
 
 namespace mozilla {
 namespace dom {
 
 class Directory;
 
 class DirectoryEntry : public Entry
 {
 public:
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(DirectoryEntry, Entry)
 
   DirectoryEntry(nsIGlobalObject* aGlobalObject, Directory* aDirectory,
-                 DOMFileSystem* aFileSystem);
+                 FileSystem* aFileSystem);
 
   virtual JSObject*
   WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
 
   virtual bool
   IsDirectory() const override
   {
     return true;

--- a/dom/filesystem/compat/DirectoryReader.cpp
+++ b/dom/filesystem/compat/DirectoryReader.cpp
@@ -20,17 +20,17 @@ namespace dom {
 namespace {
 
 class PromiseHandler final : public PromiseNativeHandler
 {
 public:
   NS_DECL_ISUPPORTS
 
   PromiseHandler(nsIGlobalObject* aGlobalObject,
-                 DOMFileSystem* aFileSystem,
+                 FileSystem* aFileSystem,
                  EntriesCallback* aSuccessCallback,
                  ErrorCallback* aErrorCallback)
     : mGlobal(aGlobalObject)
     , mFileSystem(aFileSystem)
     , mSuccessCallback(aSuccessCallback)
     , mErrorCallback(aErrorCallback)
   {
     MOZ_ASSERT(aGlobalObject);
@@ -101,17 +101,17 @@ public:
       NS_WARN_IF(NS_FAILED(rv));
     }
   }
 
 private:
   ~PromiseHandler() {}
 
   nsCOMPtr<nsIGlobalObject> mGlobal;
-  RefPtr<DOMFileSystem> mFileSystem;
+  RefPtr<FileSystem> mFileSystem;
   RefPtr<EntriesCallback> mSuccessCallback;
   RefPtr<ErrorCallback> mErrorCallback;
 };
 
 NS_IMPL_ISUPPORTS0(PromiseHandler);
 
 } // anonymous namespace
 
@@ -122,17 +122,17 @@ NS_IMPL_CYCLE_COLLECTING_ADDREF(Director
 NS_IMPL_CYCLE_COLLECTING_RELEASE(DirectoryReader)
 
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DirectoryReader)
   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
   NS_INTERFACE_MAP_ENTRY(nsISupports)
 NS_INTERFACE_MAP_END
 
 DirectoryReader::DirectoryReader(nsIGlobalObject* aGlobal,
-                                 DOMFileSystem* aFileSystem,
+                                 FileSystem* aFileSystem,
                                  Directory* aDirectory)
   : mParent(aGlobal)
   , mFileSystem(aFileSystem)
   , mDirectory(aDirectory)
   , mAlreadyRead(false)
 {
   MOZ_ASSERT(aGlobal);
   MOZ_ASSERT(aFileSystem);

--- a/dom/filesystem/compat/DirectoryReader.h
+++ b/dom/filesystem/compat/DirectoryReader.h
@@ -14,28 +14,28 @@
 #include "nsWrapperCache.h"
 
 class nsIGlobalObject;
 
 namespace mozilla {
 namespace dom {
 
 class Directory;
-class DOMFileSystem;
+class FileSystem;
 
 class DirectoryReader
   : public nsISupports
   , public nsWrapperCache
 {
 public:
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(DirectoryReader)
 
   explicit DirectoryReader(nsIGlobalObject* aGlobalObject,
-                           DOMFileSystem* aFileSystem,
+                           FileSystem* aFileSystem,
                            Directory* aDirectory);
 
   nsIGlobalObject*
   GetParentObject() const
   {
     return mParent;
   }
 
@@ -47,17 +47,17 @@ public:
               const Optional<OwningNonNull<ErrorCallback>>& aErrorCallback,
               ErrorResult& aRv);
 
 protected:
   virtual ~DirectoryReader();
 
 private:
   nsCOMPtr<nsIGlobalObject> mParent;
-  RefPtr<DOMFileSystem> mFileSystem;
+  RefPtr<FileSystem> mFileSystem;
   RefPtr<Directory> mDirectory;
 
   bool mAlreadyRead;
 };
 
 } // namespace dom
 } // namespace mozilla
 

--- a/dom/filesystem/compat/Entry.cpp
+++ b/dom/filesystem/compat/Entry.cpp
@@ -20,17 +20,17 @@ NS_IMPL_CYCLE_COLLECTING_RELEASE(Entry)
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Entry)
   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
   NS_INTERFACE_MAP_ENTRY(nsISupports)
 NS_INTERFACE_MAP_END
 
 /* static */ already_AddRefed<Entry>
 Entry::Create(nsIGlobalObject* aGlobalObject,
               const OwningFileOrDirectory& aFileOrDirectory,
-              DOMFileSystem* aFileSystem)
+              FileSystem* aFileSystem)
 {
   MOZ_ASSERT(aGlobalObject);
   MOZ_ASSERT(aFileSystem);
 
   RefPtr<Entry> entry;
   if (aFileOrDirectory.IsFile()) {
     entry = new FileEntry(aGlobalObject,
                           aFileOrDirectory.GetAsFile(),
@@ -40,17 +40,17 @@ Entry::Create(nsIGlobalObject* aGlobalOb
     entry = new DirectoryEntry(aGlobalObject,
                                aFileOrDirectory.GetAsDirectory(),
                                aFileSystem);
   }
 
   return entry.forget();
 }
 
-Entry::Entry(nsIGlobalObject* aGlobal, DOMFileSystem* aFileSystem)
+Entry::Entry(nsIGlobalObject* aGlobal, FileSystem* aFileSystem)
   : mParent(aGlobal)
   , mFileSystem(aFileSystem)
 {
   MOZ_ASSERT(aGlobal);
   MOZ_ASSERT(aFileSystem);
 }
 
 Entry::~Entry()

--- a/dom/filesystem/compat/Entry.h
+++ b/dom/filesystem/compat/Entry.h
@@ -12,31 +12,31 @@
 #include "mozilla/dom/BindingDeclarations.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsIGlobalObject.h"
 #include "nsWrapperCache.h"
 
 namespace mozilla {
 namespace dom {
 
-class DOMFileSystem;
+class FileSystem;
 class OwningFileOrDirectory;
 
 class Entry
   : public nsISupports
   , public nsWrapperCache
 {
 public:
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(Entry)
 
   static already_AddRefed<Entry>
   Create(nsIGlobalObject* aGlobalObject,
          const OwningFileOrDirectory& aFileOrDirectory,
-         DOMFileSystem* aFileSystem);
+         FileSystem* aFileSystem);
 
   nsIGlobalObject*
   GetParentObject() const
   {
     return mParent;
   }
 
   virtual JSObject*
@@ -55,28 +55,28 @@ public:
   }
 
   virtual void
   GetName(nsAString& aName, ErrorResult& aRv) const = 0;
 
   virtual void
   GetFullPath(nsAString& aFullPath, ErrorResult& aRv) const = 0;
 
-  DOMFileSystem*
+  FileSystem*
   Filesystem() const
   {
     return mFileSystem;
   }
 
 protected:
   Entry(nsIGlobalObject* aGlobalObject,
-        DOMFileSystem* aFileSystem);
+        FileSystem* aFileSystem);
   virtual ~Entry();
 
 private:
   nsCOMPtr<nsIGlobalObject> mParent;
-  RefPtr<DOMFileSystem> mFileSystem;
+  RefPtr<FileSystem> mFileSystem;
 };
 
 } // namespace dom
 } // namespace mozilla
 
 #endif // mozilla_dom_Entry_h

--- a/dom/filesystem/compat/FileEntry.cpp
+++ b/dom/filesystem/compat/FileEntry.cpp
@@ -43,17 +43,17 @@ NS_IMPL_CYCLE_COLLECTION_INHERITED(FileE
 NS_IMPL_ADDREF_INHERITED(FileEntry, Entry)
 NS_IMPL_RELEASE_INHERITED(FileEntry, Entry)
 
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(FileEntry)
 NS_INTERFACE_MAP_END_INHERITING(Entry)
 
 FileEntry::FileEntry(nsIGlobalObject* aGlobal,
                      File* aFile,
-                     DOMFileSystem* aFileSystem)
+                     FileSystem* aFileSystem)
   : Entry(aGlobal, aFileSystem)
   , mFile(aFile)
 {
   MOZ_ASSERT(aGlobal);
   MOZ_ASSERT(mFile);
 }
 
 FileEntry::~FileEntry()

--- a/dom/filesystem/compat/FileEntry.h
+++ b/dom/filesystem/compat/FileEntry.h
@@ -16,17 +16,17 @@ class File;
 
 class FileEntry final : public Entry
 {
 public:
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(FileEntry, Entry)
 
   FileEntry(nsIGlobalObject* aGlobalObject, File* aFile,
-            DOMFileSystem* aFileSystem);
+            FileSystem* aFileSystem);
 
   virtual JSObject*
   WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
 
   virtual bool
   IsFile() const override
   {
     return true;

rename from dom/filesystem/compat/DOMFileSystem.cpp
rename to dom/filesystem/compat/FileSystem.cpp
--- a/dom/filesystem/compat/DOMFileSystem.cpp
+++ b/dom/filesystem/compat/FileSystem.cpp
@@ -1,34 +1,34 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#include "DOMFileSystem.h"
+#include "FileSystem.h"
 #include "RootDirectoryEntry.h"
-#include "mozilla/dom/DOMFileSystemBinding.h"
+#include "mozilla/dom/FileSystemBinding.h"
 #include "nsContentUtils.h"
 
 namespace mozilla {
 namespace dom {
 
-NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(DOMFileSystem, mParent, mRoot)
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(FileSystem, mParent, mRoot)
 
-NS_IMPL_CYCLE_COLLECTING_ADDREF(DOMFileSystem)
-NS_IMPL_CYCLE_COLLECTING_RELEASE(DOMFileSystem)
+NS_IMPL_CYCLE_COLLECTING_ADDREF(FileSystem)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(FileSystem)
 
-NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DOMFileSystem)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(FileSystem)
   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
   NS_INTERFACE_MAP_ENTRY(nsISupports)
 NS_INTERFACE_MAP_END
 
-/* static */ already_AddRefed<DOMFileSystem>
-DOMFileSystem::Create(nsIGlobalObject* aGlobalObject)
+/* static */ already_AddRefed<FileSystem>
+FileSystem::Create(nsIGlobalObject* aGlobalObject)
 
 {
   MOZ_ASSERT(aGlobalObject);
 
 
   nsID id;
   nsresult rv = nsContentUtils::GenerateUUIDInPlace(id);
   if (NS_WARN_IF(NS_FAILED(rv))) {
@@ -37,40 +37,39 @@ DOMFileSystem::Create(nsIGlobalObject* a
 
   char chars[NSID_LENGTH];
   id.ToProvidedString(chars);
 
   // Any fileSystem has an unique ID. We use UUID, but our generator produces
   // UUID in this format '{' + UUID + '}'. We remove them with these +1 and -2.
   nsAutoCString name(Substring(chars + 1, chars + NSID_LENGTH - 2));
 
-  RefPtr<DOMFileSystem> fs =
-    new DOMFileSystem(aGlobalObject, NS_ConvertUTF8toUTF16(name));
+  RefPtr<FileSystem> fs =
+    new FileSystem(aGlobalObject, NS_ConvertUTF8toUTF16(name));
 
   return fs.forget();
 }
 
-DOMFileSystem::DOMFileSystem(nsIGlobalObject* aGlobal,
-                             const nsAString& aName)
+FileSystem::FileSystem(nsIGlobalObject* aGlobal, const nsAString& aName)
   : mParent(aGlobal)
   , mName(aName)
 {
   MOZ_ASSERT(aGlobal);
 }
 
-DOMFileSystem::~DOMFileSystem()
+FileSystem::~FileSystem()
 {}
 
 JSObject*
-DOMFileSystem::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
+FileSystem::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
 {
-  return DOMFileSystemBinding::Wrap(aCx, this, aGivenProto);
+  return FileSystemBinding::Wrap(aCx, this, aGivenProto);
 }
 
 void
-DOMFileSystem::CreateRoot(const Sequence<RefPtr<Entry>>& aEntries)
+FileSystem::CreateRoot(const Sequence<RefPtr<Entry>>& aEntries)
 {
   MOZ_ASSERT(!mRoot);
   mRoot = new RootDirectoryEntry(mParent, aEntries, this);
 }
 
 } // dom namespace
 } // mozilla namespace

rename from dom/filesystem/compat/DOMFileSystem.h
rename to dom/filesystem/compat/FileSystem.h
--- a/dom/filesystem/compat/DOMFileSystem.h
+++ b/dom/filesystem/compat/FileSystem.h
@@ -1,41 +1,41 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#ifndef mozilla_dom_DOMFileSystem_h
-#define mozilla_dom_DOMFileSystem_h
+#ifndef mozilla_dom_FileSystem_h
+#define mozilla_dom_FileSystem_h
 
 #include "mozilla/Attributes.h"
 #include "mozilla/ErrorResult.h"
 #include "mozilla/dom/BindingDeclarations.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsWrapperCache.h"
 
 class nsIGlobalObject;
 
 namespace mozilla {
 namespace dom {
 
 class DirectoryEntry;
 class Entry;
 class OwningFileOrDirectory;
 
-class DOMFileSystem final
+class FileSystem final
   : public nsISupports
   , public nsWrapperCache
 {
 public:
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
-  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(DOMFileSystem)
+  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(FileSystem)
 
-  static already_AddRefed<DOMFileSystem>
+  static already_AddRefed<FileSystem>
   Create(nsIGlobalObject* aGlobalObject);
 
   nsIGlobalObject*
   GetParentObject() const
   {
     return mParent;
   }
 
@@ -53,21 +53,21 @@ public:
   {
     return mRoot;
   }
 
   void
   CreateRoot(const Sequence<RefPtr<Entry>>& aEntries);
 
 private:
-  explicit DOMFileSystem(nsIGlobalObject* aGlobalObject,
-                         const nsAString& aName);
-  ~DOMFileSystem();
+  explicit FileSystem(nsIGlobalObject* aGlobalObject,
+                      const nsAString& aName);
+  ~FileSystem();
 
   nsCOMPtr<nsIGlobalObject> mParent;
   RefPtr<DirectoryEntry> mRoot;
   nsString mName;
 };
 
 } // namespace dom
 } // namespace mozilla
 
-#endif // mozilla_dom_DOMFileSystem_h
+#endif // mozilla_dom_FileSystem_h

--- a/dom/filesystem/compat/RootDirectoryEntry.cpp
+++ b/dom/filesystem/compat/RootDirectoryEntry.cpp
@@ -16,17 +16,17 @@ NS_IMPL_CYCLE_COLLECTION_INHERITED(RootD
 NS_IMPL_ADDREF_INHERITED(RootDirectoryEntry, DirectoryEntry)
 NS_IMPL_RELEASE_INHERITED(RootDirectoryEntry, DirectoryEntry)
 
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(RootDirectoryEntry)
 NS_INTERFACE_MAP_END_INHERITING(DirectoryEntry)
 
 RootDirectoryEntry::RootDirectoryEntry(nsIGlobalObject* aGlobal,
                                        const Sequence<RefPtr<Entry>>& aEntries,
-                                       DOMFileSystem* aFileSystem)
+                                       FileSystem* aFileSystem)
   : DirectoryEntry(aGlobal, nullptr, aFileSystem)
   , mEntries(aEntries)
 {
   MOZ_ASSERT(aGlobal);
 }
 
 RootDirectoryEntry::~RootDirectoryEntry()
 {}

--- a/dom/filesystem/compat/RootDirectoryEntry.h
+++ b/dom/filesystem/compat/RootDirectoryEntry.h
@@ -15,17 +15,17 @@ namespace dom {
 class RootDirectoryEntry final : public DirectoryEntry
 {
 public:
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(RootDirectoryEntry, DirectoryEntry)
 
   RootDirectoryEntry(nsIGlobalObject* aGlobalObject,
                      const Sequence<RefPtr<Entry>>& aEntries,
-                     DOMFileSystem* aFileSystem);
+                     FileSystem* aFileSystem);
 
   virtual void
   GetName(nsAString& aName, ErrorResult& aRv) const override;
 
   virtual void
   GetFullPath(nsAString& aFullPath, ErrorResult& aRv) const override;
 
   virtual already_AddRefed<DirectoryReader>

--- a/dom/filesystem/compat/RootDirectoryReader.cpp
+++ b/dom/filesystem/compat/RootDirectoryReader.cpp
@@ -49,17 +49,17 @@ NS_IMPL_CYCLE_COLLECTION_INHERITED(RootD
 
 NS_IMPL_ADDREF_INHERITED(RootDirectoryReader, DirectoryReader)
 NS_IMPL_RELEASE_INHERITED(RootDirectoryReader, DirectoryReader)
 
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(RootDirectoryReader)
 NS_INTERFACE_MAP_END_INHERITING(DirectoryReader)
 
 RootDirectoryReader::RootDirectoryReader(nsIGlobalObject* aGlobal,
-                                         DOMFileSystem* aFileSystem,
+                                         FileSystem* aFileSystem,
                                          const Sequence<RefPtr<Entry>>& aEntries)
   : DirectoryReader(aGlobal, aFileSystem, nullptr)
   , mEntries(aEntries)
   , mAlreadyRead(false)
 {
   MOZ_ASSERT(aGlobal);
   MOZ_ASSERT(aFileSystem);
 }

--- a/dom/filesystem/compat/RootDirectoryReader.h
+++ b/dom/filesystem/compat/RootDirectoryReader.h
@@ -14,17 +14,17 @@ namespace dom {
 
 class RootDirectoryReader final : public DirectoryReader
 {
 public:
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(RootDirectoryReader, DirectoryReader)
 
   explicit RootDirectoryReader(nsIGlobalObject* aGlobalObject,
-                               DOMFileSystem* aFileSystem,
+                               FileSystem* aFileSystem,
                                const Sequence<RefPtr<Entry>>& aEntries);
 
   virtual void
   ReadEntries(EntriesCallback& aSuccessCallback,
               const Optional<OwningNonNull<ErrorCallback>>& aErrorCallback,
               ErrorResult& aRv) override;
 
 private:

--- a/dom/filesystem/compat/moz.build
+++ b/dom/filesystem/compat/moz.build
@@ -4,27 +4,27 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 TEST_DIRS += ['tests']
 
 EXPORTS.mozilla.dom += [
     'DirectoryEntry.h',
     'DirectoryReader.h',
-    'DOMFileSystem.h',
     'Entry.h',
     'FileEntry.h',
+    'FileSystem.h',
 ]
 
 UNIFIED_SOURCES += [
     'CallbackRunnables.cpp',
     'DirectoryEntry.cpp',
     'DirectoryReader.cpp',
-    'DOMFileSystem.cpp',
     'Entry.cpp',
     'FileEntry.cpp',
+    'FileSystem.cpp',
     'RootDirectoryEntry.cpp',
     'RootDirectoryReader.cpp',
 ]
 
 FINAL_LIBRARY = 'xul'
 
 include('/ipc/chromium/chromium-config.mozbuild')

--- a/dom/html/HTMLInputElement.cpp
+++ b/dom/html/HTMLInputElement.cpp
@@ -75,17 +75,17 @@
 #include "nsRuleData.h"
 #include <algorithm>
 
 // input type=radio
 #include "nsIRadioGroupContainer.h"
 
 // input type=file
 #include "mozilla/dom/Entry.h"
-#include "mozilla/dom/DOMFileSystem.h"
+#include "mozilla/dom/FileSystem.h"
 #include "mozilla/dom/File.h"
 #include "mozilla/dom/FileList.h"
 #include "nsIFile.h"
 #include "nsNetCID.h"
 #include "nsNetUtil.h"
 #include "nsDirectoryServiceDefs.h"
 #include "nsIContentPrefService.h"
 #include "nsIMIMEService.h"
@@ -8254,17 +8254,17 @@ HTMLInputElement::GetOrCreateGetFilesHel
 void
 HTMLInputElement::UpdateEntries(const nsTArray<OwningFileOrDirectory>& aFilesOrDirectories)
 {
   MOZ_ASSERT(mEntries.IsEmpty());
 
   nsCOMPtr<nsIGlobalObject> global = OwnerDoc()->GetScopeObject();
   MOZ_ASSERT(global);
 
-  RefPtr<DOMFileSystem> fs = DOMFileSystem::Create(global);
+  RefPtr<FileSystem> fs = FileSystem::Create(global);
   if (NS_WARN_IF(!fs)) {
     return;
   }
 
   Sequence<RefPtr<Entry>> entries;
   for (uint32_t i = 0; i < aFilesOrDirectories.Length(); ++i) {
     RefPtr<Entry> entry = Entry::Create(global, aFilesOrDirectories[i], fs);
     MOZ_ASSERT(entry);

rename from dom/webidl/DOMFileSystem.webidl
rename to dom/webidl/FileSystem.webidl
--- a/dom/webidl/DOMFileSystem.webidl
+++ b/dom/webidl/FileSystem.webidl
@@ -10,17 +10,17 @@ interface Entry {
     readonly attribute boolean isDirectory;
 
     [GetterThrows]
     readonly attribute DOMString name;
 
     [GetterThrows]
     readonly attribute DOMString fullPath;
 
-    readonly attribute DOMFileSystem filesystem;
+    readonly attribute FileSystem filesystem;
 
 /** Not implemented:
  *  void getMetadata(MetadataCallback successCallback, optional ErrorCallback errorCallback);
  *  void moveTo(DirectoryEntry parent, optional DOMString? name, optional EntryCallback successCallback, optional ErrorCallback errorCallback);
  *  void copyTo(DirectoryEntry parent, optional DOMString? name, optional EntryCallback successCallback, optional ErrorCallback errorCallback);
  *  DOMString toURL();
  *  void remove(VoidCallback successCallback, optional ErrorCallback errorCallback);
  *  void getParent(optional EntryCallback successCallback, optional ErrorCallback errorCallback);
@@ -82,12 +82,12 @@ interface FileEntry : Entry {
     // NS_ERROR_DOM_NOT_SUPPORTED_ERR.
     void createWriter (VoidCallback successCallback, optional ErrorCallback errorCallback);
 
     [BinaryName="GetFile"]
     void file (BlobCallback successCallback, optional ErrorCallback errorCallback);
 };
 
 [NoInterfaceObject]
-interface DOMFileSystem {
+interface FileSystem {
     readonly    attribute DOMString      name;
     readonly    attribute DirectoryEntry root;
 };

--- a/dom/webidl/moz.build
+++ b/dom/webidl/moz.build
@@ -123,17 +123,16 @@ WEBIDL_FILES = [
     'DisplayPortInputPort.webidl',
     'Document.webidl',
     'DocumentFragment.webidl',
     'DocumentTimeline.webidl',
     'DocumentType.webidl',
     'DOMCursor.webidl',
     'DOMError.webidl',
     'DOMException.webidl',
-    'DOMFileSystem.webidl',
     'DOMImplementation.webidl',
     'DominatorTree.webidl',
     'DOMMatrix.webidl',
     'DOMMobileMessageError.webidl',
     'DOMParser.webidl',
     'DOMPoint.webidl',
     'DOMQuad.webidl',
     'DOMRect.webidl',
@@ -157,16 +156,17 @@ WEBIDL_FILES = [
     'FakePluginTagInit.webidl',
     'Fetch.webidl',
     'FetchEvent.webidl',
     'File.webidl',
     'FileList.webidl',
     'FileMode.webidl',
     'FileReader.webidl',
     'FileReaderSync.webidl',
+    'FileSystem.webidl',
     'FlyWebDiscoveryManager.webidl',
     'FlyWebFetchEvent.webidl',
     'FlyWebPublish.webidl',
     'FlyWebWebSocketEvent.webidl',
     'FocusEvent.webidl',
     'FontFace.webidl',
     'FontFaceSet.webidl',
     'FontFaceSource.webidl',