mojo leveldb: Remove the created file thread.

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 "base/trace_event/trace_event.h"
 #include "third_party/leveldatabase/chromium_logger.h"
@@ skipping 23 matching lines @@
       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);
 }
 
 class MojoFileLock : public FileLock {
  public:
-  MojoFileLock(LevelDBFileThread::OpaqueLock* lock, const std::string& name)
+  MojoFileLock(LevelDBMojoProxy::OpaqueLock* lock, const std::string& name)
       : fname_(name), lock_(lock) {}
   ~MojoFileLock() override { DCHECK(!lock_); }
 
   const std::string& name() const { return fname_; }
 
-  LevelDBFileThread::OpaqueLock* TakeLock() {
-    LevelDBFileThread::OpaqueLock* to_return = lock_;
+  LevelDBMojoProxy::OpaqueLock* TakeLock() {
+    LevelDBMojoProxy::OpaqueLock* to_return = lock_;
     lock_ = nullptr;
     return to_return;
   }
 
  private:
   std::string fname_;
-  LevelDBFileThread::OpaqueLock* lock_;
+  LevelDBMojoProxy::OpaqueLock* lock_;
 };
 
 class MojoSequentialFile : public leveldb::SequentialFile {
  public:
   MojoSequentialFile(const std::string& fname, base::File f)
       : filename_(fname), file_(std::move(f)) {}
   ~MojoSequentialFile() override {}
 
   Status Read(size_t n, Slice* result, char* scratch) override {
     int bytes_read = file_.ReadAtCurrentPosNoBestEffort(
@@ skipping 49 matching lines @@
 
  private:
   std::string filename_;
   mutable base::File file_;
 
   DISALLOW_COPY_AND_ASSIGN(MojoRandomAccessFile);
 };
 
 class MojoWritableFile : public leveldb::WritableFile {
  public:
-  MojoWritableFile(LevelDBFileThread::OpaqueDir* dir,
+  MojoWritableFile(LevelDBMojoProxy::OpaqueDir* dir,
                    const std::string& fname,
                    base::File f,
-                   scoped_refptr<LevelDBFileThread> thread)
+                   scoped_refptr<LevelDBMojoProxy> thread)
       : filename_(fname),
         file_(std::move(f)),
         file_type_(kOther),
         dir_(dir),
         thread_(thread) {
     base::FilePath path = base::FilePath::FromUTF8Unsafe(fname);
     if (path.BaseName().AsUTF8Unsafe().find("MANIFEST") == 0)
       file_type_ = kManifest;
     else if (path.MatchesExtension(table_extension))
       file_type_ = kTable;
@@ skipping 53 matching lines @@
     return error == filesystem::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_;
-  LevelDBFileThread::OpaqueDir* dir_;
+  LevelDBMojoProxy::OpaqueDir* dir_;
   std::string parent_dir_;
-  scoped_refptr<LevelDBFileThread> thread_;
+  scoped_refptr<LevelDBMojoProxy> thread_;
 
   DISALLOW_COPY_AND_ASSIGN(MojoWritableFile);
 };
 
 }  // namespace
 
-MojoEnv::MojoEnv(scoped_refptr<LevelDBFileThread> file_thread,
-                 LevelDBFileThread::OpaqueDir* dir)
-    : thread_(file_thread),
-      dir_(dir) {
-}
+MojoEnv::MojoEnv(scoped_refptr<LevelDBMojoProxy> file_thread,
+                 LevelDBMojoProxy::OpaqueDir* dir)
+    : thread_(file_thread), dir_(dir) {}
 
 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),
@@ skipping 97 matching lines @@
 
 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, LevelDBFileThread::OpaqueLock*> p =
+  std::pair<filesystem::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);
@@ skipping 24 matching lines @@
     *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