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

components/leveldb/leveldb_mojo_proxy.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/leveldb_mojo_proxy.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 167 matching lines @@
   delete dir;
   outstanding_opaque_dirs_--;
 }
 
 void LevelDBMojoProxy::OpenFileHandleImpl(OpaqueDir* dir,
                                           std::string name,
                                           uint32_t open_flags,
                                           base::File* output_file) {
   mojo::ScopedHandle handle;
   filesystem::mojom::FileError error = filesystem::mojom::FileError::FAILED;
-  bool completed = dir->directory->OpenFileHandle(mojo::String::From(name),
-                                                  open_flags, &error, &handle);
+  bool completed =
+      dir->directory->OpenFileHandle(name, open_flags, &error, &handle);
   DCHECK(completed);
 
   if (error != filesystem::mojom::FileError::OK) {
     *output_file = base::File(static_cast<base::File::Error>(error));
   } else {
     base::PlatformFile platform_file;
     MojoResult unwrap_result = mojo::UnwrapPlatformFile(std::move(handle),
                                                         &platform_file);
     if (unwrap_result == MOJO_RESULT_OK) {
       *output_file = base::File(platform_file);
@@ skipping 18 matching lines @@
     return;
 
   completed = target->Flush(out_error);
   DCHECK(completed);
 }
 
 void LevelDBMojoProxy::FileExistsImpl(OpaqueDir* dir,
                                       std::string name,
                                       bool* exists) {
   filesystem::mojom::FileError error = filesystem::mojom::FileError::FAILED;
-  bool completed =
-      dir->directory->Exists(mojo::String::From(name), &error, exists);
+  bool completed = dir->directory->Exists(name, &error, exists);
   DCHECK(completed);
 }
 
 void LevelDBMojoProxy::GetChildrenImpl(
     OpaqueDir* dir,
     std::string name,
     std::vector<std::string>* out_contents,
     filesystem::mojom::FileError* out_error) {
   filesystem::mojom::DirectoryPtr target;
   filesystem::mojom::DirectoryRequest proxy = GetProxy(&target);
   bool completed = dir->directory->OpenDirectory(
       name, std::move(proxy),
       filesystem::mojom::kFlagRead | filesystem::mojom::kFlagWrite, out_error);
   DCHECK(completed);
 
   if (*out_error != filesystem::mojom::FileError::OK)
     return;
 
-  mojo::Array<filesystem::mojom::DirectoryEntryPtr> directory_contents;
+  base::Optional<std::vector<filesystem::mojom::DirectoryEntryPtr>>
+      directory_contents;
   completed = target->Read(out_error, &directory_contents);
   DCHECK(completed);
 
-  if (!directory_contents.is_null()) {
-    for (size_t i = 0; i < directory_contents.size(); ++i)
-      out_contents->push_back(directory_contents[i]->name.To<std::string>());
+  if (directory_contents.has_value()) {
+    for (size_t i = 0; i < directory_contents->size(); ++i)
+      out_contents->push_back(directory_contents.value()[i]->name);
   }
 }
 
 void LevelDBMojoProxy::DeleteImpl(OpaqueDir* dir,
                                   std::string name,
                                   uint32_t delete_flags,
                                   filesystem::mojom::FileError* out_error) {
-  bool completed =
-      dir->directory->Delete(mojo::String::From(name), delete_flags, out_error);
+  bool completed = dir->directory->Delete(name, delete_flags, out_error);
   DCHECK(completed);
 }
 
 void LevelDBMojoProxy::CreateDirImpl(OpaqueDir* dir,
                                      std::string name,
                                      filesystem::mojom::FileError* out_error) {
   bool completed = dir->directory->OpenDirectory(
       name, nullptr,
       filesystem::mojom::kFlagRead | filesystem::mojom::kFlagWrite |
           filesystem::mojom::kFlagCreate,
@@ skipping 10 matching lines @@
   bool completed = dir->directory->StatFile(path, out_error, &info);
   DCHECK(completed);
   if (info)
     *file_size = info->size;
 }
 
 void LevelDBMojoProxy::RenameFileImpl(OpaqueDir* dir,
                                       const std::string& old_path,
                                       const std::string& new_path,
                                       filesystem::mojom::FileError* out_error) {
-  bool completed = dir->directory->Rename(
-      mojo::String::From(old_path), mojo::String::From(new_path), out_error);
+  bool completed = dir->directory->Rename(old_path, new_path, out_error);
   DCHECK(completed);
 }
 
 void LevelDBMojoProxy::LockFileImpl(OpaqueDir* dir,
                                     const std::string& path,
                                     filesystem::mojom::FileError* out_error,
                                     OpaqueLock** out_lock) {
   // Since a lock is associated with a file descriptor, we need to open and
   // have a persistent file on the other side of the connection.
   filesystem::mojom::FilePtr target;
   filesystem::mojom::FileRequest proxy = GetProxy(&target);
-  bool completed = dir->directory->OpenFile(
-      mojo::String::From(path), std::move(proxy),
-      filesystem::mojom::kFlagOpenAlways | filesystem::mojom::kFlagRead |
-          filesystem::mojom::kFlagWrite,
-      out_error);
+  bool completed = dir->directory->OpenFile(path, std::move(proxy),
+                                            filesystem::mojom::kFlagOpenAlways |
+                                                filesystem::mojom::kFlagRead |
+                                                filesystem::mojom::kFlagWrite,
+                                            out_error);
   DCHECK(completed);
 
   if (*out_error != filesystem::mojom::FileError::OK)
     return;
 
   completed = target->Lock(out_error);
   DCHECK(completed);
 
   if (*out_error == filesystem::mojom::FileError::OK) {
     OpaqueLock* l = new OpaqueLock;
     l->lock_file = std::move(target);
     *out_lock = l;
   }
 }
 
 void LevelDBMojoProxy::UnlockFileImpl(std::unique_ptr<OpaqueLock> lock,
                                       filesystem::mojom::FileError* out_error) {
   lock->lock_file->Unlock(out_error);
 }
 
 }  // namespace leveldb