Mojo C++ bindings: switch components/filesystem mojom target to use STL types.

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>
 
@@ skipping 211 matching lines @@
     : 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),
-      filesystem::mojom::kFlagOpen | filesystem::mojom::kFlagRead);
+      dir_, fname, 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::mojom::kFlagRead | filesystem::mojom::kFlagOpen);
+      dir_, fname, 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::mojom::kCreateAlways | filesystem::mojom::kFlagWrite);
+  base::File f =
+      thread_->OpenFileHandle(dir_, fname, 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::mojom::kFlagOpenAlways | filesystem::mojom::kFlagAppend);
+  base::File f =
+      thread_->OpenFileHandle(dir_, fname, 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 38 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::mojom::FileError, LevelDBMojoProxy::OpaqueLock*> p =
-      thread_->LockFile(dir_, mojo::String::From(fname));
+      thread_->LockFile(dir_, 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 11 matching lines @@
   // service_manager::ServiceTest,
   // 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);
   base::File f(thread_->OpenFileHandle(
-      dir_, mojo::String::From(fname),
+      dir_, fname,
       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(std::move(f));
     return Status::OK();
   }
 }
 
 }  // namespace leveldb