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

components/leveldb/env_mojo.cc

 // Copyright 2016 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.
 
 #include "components/leveldb/env_mojo.h"
 
 #include <errno.h>
 
 #include <memory>
 
 #include "base/trace_event/trace_event.h"
 #include "third_party/leveldatabase/chromium_logger.h"
 #include "third_party/leveldatabase/src/include/leveldb/status.h"
 
 namespace leveldb {
 
 namespace {
 
 const base::FilePath::CharType table_extension[] = FILE_PATH_LITERAL(".ldb");
 
 base::File::Error LastFileError() {
 #if defined(OS_WIN)
   return base::File::OSErrorToFileError(GetLastError());
 #else
   return base::File::OSErrorToFileError(errno);
 #endif
 }
 
-Status FilesystemErrorToStatus(filesystem::FileError error,
+Status FilesystemErrorToStatus(filesystem::mojom::FileError error,
                                const std::string& filename,
                                leveldb_env::MethodID method) {
-  if (error == filesystem::FileError::OK)
+  if (error == filesystem::mojom::FileError::OK)
     return Status::OK();
 
   std::string err_str =
       base::File::ErrorToString(base::File::Error(static_cast<int>(error)));
 
   char buf[512];
   snprintf(buf, sizeof(buf), "%s (MojoFSError: %d::%s)", err_str.c_str(),
            method, MethodIDToString(method));
   return Status::IOError(filename, buf);
 }
@@ skipping 143 matching lines @@
     if (file_type_ == kManifest)
       return SyncParent();
 
     return Status::OK();
   }
 
  private:
   enum Type { kManifest, kTable, kOther };
 
   leveldb::Status SyncParent() {
-    filesystem::FileError error = thread_->SyncDirectory(dir_, parent_dir_);
-    return error == filesystem::FileError::OK
+    filesystem::mojom::FileError error =
+        thread_->SyncDirectory(dir_, parent_dir_);
+    return error == filesystem::mojom::FileError::OK
                ? Status::OK()
                : Status::IOError(filename_,
                                  base::File::ErrorToString(base::File::Error(
                                      static_cast<int>(error))));
   }
 
   std::string filename_;
   base::File file_;
   Type file_type_;
   LevelDBMojoProxy::OpaqueDir* dir_;
@@ skipping 11 matching lines @@
 
 MojoEnv::~MojoEnv() {
   thread_->UnregisterDirectory(dir_);
 }
 
 Status MojoEnv::NewSequentialFile(const std::string& fname,
                                   SequentialFile** result) {
   TRACE_EVENT1("leveldb", "MojoEnv::NewSequentialFile", "fname", fname);
   base::File f = thread_->OpenFileHandle(
       dir_, mojo::String::From(fname),
-      filesystem::kFlagOpen | filesystem::kFlagRead);
+      filesystem::mojom::kFlagOpen | filesystem::mojom::kFlagRead);
   if (!f.IsValid()) {
     *result = nullptr;
     return MakeIOError(fname, "Unable to create sequential file",
                        leveldb_env::kNewSequentialFile, f.error_details());
   }
 
   *result = new MojoSequentialFile(fname, std::move(f));
   return Status::OK();
 }
 
 Status MojoEnv::NewRandomAccessFile(const std::string& fname,
                                     RandomAccessFile** result) {
   TRACE_EVENT1("leveldb", "MojoEnv::NewRandomAccessFile", "fname", fname);
   base::File f = thread_->OpenFileHandle(
       dir_, mojo::String::From(fname),
-      filesystem::kFlagRead | filesystem::kFlagOpen);
+      filesystem::mojom::kFlagRead | filesystem::mojom::kFlagOpen);
   if (!f.IsValid()) {
     *result = nullptr;
     base::File::Error error_code = f.error_details();
     return MakeIOError(fname, FileErrorString(error_code),
                        leveldb_env::kNewRandomAccessFile, error_code);
   }
 
   *result = new MojoRandomAccessFile(fname, std::move(f));
   return Status::OK();
 }
 
 Status MojoEnv::NewWritableFile(const std::string& fname,
                                 WritableFile** result) {
   TRACE_EVENT1("leveldb", "MojoEnv::NewWritableFile", "fname", fname);
   base::File f = thread_->OpenFileHandle(
       dir_, mojo::String::From(fname),
-      filesystem::kCreateAlways | filesystem::kFlagWrite);
+      filesystem::mojom::kCreateAlways | filesystem::mojom::kFlagWrite);
   if (!f.IsValid()) {
     *result = nullptr;
     return MakeIOError(fname, "Unable to create writable file",
                        leveldb_env::kNewWritableFile, f.error_details());
   }
 
   *result = new MojoWritableFile(dir_, fname, std::move(f), thread_);
   return Status::OK();
 }
 
 Status MojoEnv::NewAppendableFile(const std::string& fname,
                                   WritableFile** result) {
   TRACE_EVENT1("leveldb", "MojoEnv::NewAppendableFile", "fname", fname);
   base::File f = thread_->OpenFileHandle(
       dir_, mojo::String::From(fname),
-      filesystem::kFlagOpenAlways | filesystem::kFlagAppend);
+      filesystem::mojom::kFlagOpenAlways | filesystem::mojom::kFlagAppend);
   if (!f.IsValid()) {
     *result = nullptr;
     return MakeIOError(fname, "Unable to create appendable file",
                        leveldb_env::kNewAppendableFile, f.error_details());
   }
 
   *result = new MojoWritableFile(dir_, fname, std::move(f), thread_);
   return Status::OK();
 }
 
@@ skipping 17 matching lines @@
 
 Status MojoEnv::CreateDir(const std::string& dirname) {
   TRACE_EVENT1("leveldb", "MojoEnv::CreateDir", "dirname", dirname);
   return FilesystemErrorToStatus(thread_->CreateDir(dir_, dirname), dirname,
                                  leveldb_env::kCreateDir);
 }
 
 Status MojoEnv::DeleteDir(const std::string& dirname) {
   TRACE_EVENT1("leveldb", "MojoEnv::DeleteDir", "dirname", dirname);
   return FilesystemErrorToStatus(
-      thread_->Delete(dir_, dirname, filesystem::kDeleteFlagRecursive), dirname,
-      leveldb_env::kDeleteDir);
+      thread_->Delete(dir_, dirname, filesystem::mojom::kDeleteFlagRecursive),
+      dirname, leveldb_env::kDeleteDir);
 }
 
 Status MojoEnv::GetFileSize(const std::string& fname, uint64_t* file_size) {
   TRACE_EVENT1("leveldb", "MojoEnv::GetFileSize", "fname", fname);
   return FilesystemErrorToStatus(thread_->GetFileSize(dir_, fname, file_size),
                                  fname,
                                  leveldb_env::kGetFileSize);
 }
 
 Status MojoEnv::RenameFile(const std::string& src, const std::string& target) {
   TRACE_EVENT2("leveldb", "MojoEnv::RenameFile", "src", src, "target", target);
   return FilesystemErrorToStatus(thread_->RenameFile(dir_, src, target), src,
                                  leveldb_env::kRenameFile);
 }
 
 Status MojoEnv::LockFile(const std::string& fname, FileLock** lock) {
   TRACE_EVENT1("leveldb", "MojoEnv::LockFile", "fname", fname);
 
-  std::pair<filesystem::FileError, LevelDBMojoProxy::OpaqueLock*> p =
+  std::pair<filesystem::mojom::FileError, LevelDBMojoProxy::OpaqueLock*> p =
       thread_->LockFile(dir_, mojo::String::From(fname));
 
   if (p.second)
     *lock = new MojoFileLock(p.second, fname);
 
   return FilesystemErrorToStatus(p.first, fname, leveldb_env::kLockFile);
 }
 
 Status MojoEnv::UnlockFile(FileLock* lock) {
   MojoFileLock* my_lock = reinterpret_cast<MojoFileLock*>(lock);
 
   std::string fname = my_lock ? my_lock->name() : "(invalid)";
   TRACE_EVENT1("leveldb", "MojoEnv::UnlockFile", "fname", fname);
 
-  filesystem::FileError err = thread_->UnlockFile(my_lock->TakeLock());
+  filesystem::mojom::FileError err = thread_->UnlockFile(my_lock->TakeLock());
   delete my_lock;
   return FilesystemErrorToStatus(err, fname, leveldb_env::kUnlockFile);
 }
 
 Status MojoEnv::GetTestDirectory(std::string* path) {
   // TODO(erg): This method is actually only used from the test harness in
   // leveldb. And when we go and port that test stuff to a mojo apptest, we
   // probably won't use it since the mojo filesystem actually handles temporary
   // filesystems just fine.
   NOTREACHED();
   return Status::OK();
 }
 
 Status MojoEnv::NewLogger(const std::string& fname, Logger** result) {
   TRACE_EVENT1("leveldb", "MojoEnv::NewLogger", "fname", fname);
   std::unique_ptr<base::File> f(new base::File(thread_->OpenFileHandle(
       dir_, mojo::String::From(fname),
-      filesystem::kCreateAlways | filesystem::kFlagWrite)));
+      filesystem::mojom::kCreateAlways | filesystem::mojom::kFlagWrite)));
   if (!f->IsValid()) {
     *result = NULL;
     return MakeIOError(fname, "Unable to create log file",
                        leveldb_env::kNewLogger, f->error_details());
   } else {
     *result = new leveldb::ChromiumLogger(f.release());
     return Status::OK();
   }
 }
 
 }  // namespace leveldb