Add mojom module suffix in .mojom files for components/filesystem.

components/leveldb/leveldb_mojo_proxy.h

Index: components/leveldb/leveldb_mojo_proxy.h
diff --git a/components/leveldb/leveldb_mojo_proxy.h b/components/leveldb/leveldb_mojo_proxy.h
index cced2b2192d97a46c83214d6284f5d2fe284e00d..881e8b7e0dacdaf3234554bb7b3bcb00820fda05 100644
--- a/components/leveldb/leveldb_mojo_proxy.h
+++ b/components/leveldb/leveldb_mojo_proxy.h
@@ -47,7 +47,7 @@ class LevelDBMojoProxy : public base::RefCountedThreadSafe<LevelDBMojoProxy> {
 
   // Passes ownership of a |directory| to the other thread, giving a reference
   // handle back to the caller.
-  OpaqueDir* RegisterDirectory(filesystem::DirectoryPtr directory);
+  OpaqueDir* RegisterDirectory(filesystem::mojom::DirectoryPtr directory);
   void UnregisterDirectory(OpaqueDir* dir);
 
   // Synchronously calls Directory.OpenFileHandle().
@@ -56,45 +56,47 @@ class LevelDBMojoProxy : public base::RefCountedThreadSafe<LevelDBMojoProxy> {
                             uint32_t open_flags);
 
   // Synchronously syncs |directory_|.
-  filesystem::FileError SyncDirectory(OpaqueDir* dir, const std::string& name);
+  filesystem::mojom::FileError SyncDirectory(OpaqueDir* dir,
+                                             const std::string& name);
 
   // Synchronously checks whether |name| exists.
   bool FileExists(OpaqueDir* dir, const std::string& name);
 
   // Synchronously returns the filenames of all files in |path|.
-  filesystem::FileError GetChildren(OpaqueDir* dir,
-                                    const std::string& path,
-                                    std::vector<std::string>* result);
+  filesystem::mojom::FileError GetChildren(OpaqueDir* dir,
+                                           const std::string& path,
+                                           std::vector<std::string>* result);
 
   // Synchronously deletes |path|.
-  filesystem::FileError Delete(OpaqueDir* dir,
-                               const std::string& path,
-                               uint32_t delete_flags);
+  filesystem::mojom::FileError Delete(OpaqueDir* dir,
+                                      const std::string& path,
+                                      uint32_t delete_flags);
 
   // Synchronously creates |path|.
-  filesystem::FileError CreateDir(OpaqueDir* dir, const std::string& path);
+  filesystem::mojom::FileError CreateDir(OpaqueDir* dir,
+                                         const std::string& path);
 
   // Synchronously gets the size of a file.
-  filesystem::FileError GetFileSize(OpaqueDir* dir,
-                                    const std::string& path,
-                                    uint64_t* file_size);
+  filesystem::mojom::FileError GetFileSize(OpaqueDir* dir,
+                                           const std::string& path,
+                                           uint64_t* file_size);
 
   // Synchronously renames a file.
-  filesystem::FileError RenameFile(OpaqueDir* dir,
-                                   const std::string& old_path,
-                                   const std::string& new_path);
+  filesystem::mojom::FileError RenameFile(OpaqueDir* dir,
+                                          const std::string& old_path,
+                                          const std::string& new_path);
 
   // Synchronously locks a file. Returns both the file return code, and if OK,
   // an opaque object to the lock to enforce going through this interface to
   // unlock the file so that unlocking happens on the correct thread.
-  std::pair<filesystem::FileError, OpaqueLock*> LockFile(
+  std::pair<filesystem::mojom::FileError, OpaqueLock*> LockFile(
       OpaqueDir* dir,
       const std::string& path);
 
   // Unlocks a file. LevelDBMojoProxy takes ownership of lock. (We don't make
   // this a scoped_ptr because exporting the ctor/dtor for this struct publicly
   // defeats the purpose of the struct.)
-  filesystem::FileError UnlockFile(OpaqueLock* lock);
+  filesystem::mojom::FileError UnlockFile(OpaqueLock* lock);
 
  private:
   friend class base::RefCountedThreadSafe<LevelDBMojoProxy>;
@@ -108,7 +110,7 @@ class LevelDBMojoProxy : public base::RefCountedThreadSafe<LevelDBMojoProxy> {
   // were called from the thread that |task_runner_| is, these might be run
   // on the current thread or through PostTask().
   void RegisterDirectoryImpl(
-      mojo::InterfacePtrInfo<filesystem::Directory> directory_info,
+      mojo::InterfacePtrInfo<filesystem::mojom::Directory> directory_info,
       OpaqueDir** out_dir);
   void UnregisterDirectoryImpl(OpaqueDir* dir);
   void OpenFileHandleImpl(OpaqueDir* dir,
@@ -117,35 +119,35 @@ class LevelDBMojoProxy : public base::RefCountedThreadSafe<LevelDBMojoProxy> {
                           base::File* out_file);
   void SyncDirectoryImpl(OpaqueDir* dir,
                          std::string name,
-                         filesystem::FileError* out_error);
+                         filesystem::mojom::FileError* out_error);
   void FileExistsImpl(OpaqueDir* dir,
                       std::string name,
                       bool* exists);
   void GetChildrenImpl(OpaqueDir* dir,
                        std::string name,
                        std::vector<std::string>* contents,
-                       filesystem::FileError* out_error);
+                       filesystem::mojom::FileError* out_error);
   void DeleteImpl(OpaqueDir* dir,
                   std::string name,
                   uint32_t delete_flags,
-                  filesystem::FileError* out_error);
+                  filesystem::mojom::FileError* out_error);
   void CreateDirImpl(OpaqueDir* dir,
                      std::string name,
-                     filesystem::FileError* out_error);
+                     filesystem::mojom::FileError* out_error);
   void GetFileSizeImpl(OpaqueDir* dir,
                        const std::string& path,
                        uint64_t* file_size,
-                       filesystem::FileError* out_error);
+                       filesystem::mojom::FileError* out_error);
   void RenameFileImpl(OpaqueDir* dir,
                       const std::string& old_path,
                       const std::string& new_path,
-                      filesystem::FileError* out_error);
+                      filesystem::mojom::FileError* out_error);
   void LockFileImpl(OpaqueDir* dir,
                     const std::string& path,
-                    filesystem::FileError* out_error,
+                    filesystem::mojom::FileError* out_error,
                     OpaqueLock** out_lock);
   void UnlockFileImpl(std::unique_ptr<OpaqueLock> lock,
-                      filesystem::FileError* out_error);
+                      filesystem::mojom::FileError* out_error);
 
   // The task runner which represents the thread that all mojo objects are
   // bound to.