Eliminate mojo:resource_provider

components/filesystem/directory_impl.cc

 // Copyright 2015 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/filesystem/directory_impl.h"
 
 #include <utility>
 
 #include "base/files/file.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "build/build_config.h"
 #include "components/filesystem/file_impl.h"
 #include "components/filesystem/lock_table.h"
 #include "components/filesystem/util.h"
 #include "mojo/common/common_type_converters.h"
 #include "mojo/platform_handle/platform_handle_functions.h"
 
-using mojo::ScopedHandle;
-
 namespace filesystem {
 
 DirectoryImpl::DirectoryImpl(mojo::InterfaceRequest<Directory> request,
                              base::FilePath directory_path,
                              scoped_refptr<SharedTempDir> temp_dir,
                              scoped_refptr<LockTable> lock_table)
     : binding_(this, std::move(request)),
       directory_path_(directory_path),
       temp_dir_(std::move(temp_dir)),
       lock_table_(std::move(lock_table)) {}
@@ skipping 51 matching lines @@
   if (file.is_pending()) {
     new FileImpl(std::move(file), path, std::move(base_file), temp_dir_,
                  lock_table_);
   }
   callback.Run(FileError::OK);
 }
 
 void DirectoryImpl::OpenFileHandle(const mojo::String& raw_path,
                                    uint32_t open_flags,
                                    const OpenFileHandleCallback& callback) {
-  base::FilePath path;
-  FileError error = ValidatePath(raw_path, directory_path_, &path);
-  if (error != FileError::OK) {
-    callback.Run(error, ScopedHandle());
-    return;
+  FileError error = FileError::OK;
+  mojo::ScopedHandle handle = OpenFileHandleImpl(raw_path, open_flags, &error);
+  callback.Run(error, std::move(handle));
+}
+
+void DirectoryImpl::OpenFileHandles(mojo::Array<FileOpenDetailsPtr> details,
+                                    const OpenFileHandlesCallback& callback) {
+  mojo::Array<FileOpenResultPtr> results(
+      mojo::Array<FileOpenResultPtr>::New(details.size()));
+  size_t i = 0;
+  for (const auto& detail : details) {
+    FileOpenResultPtr result(FileOpenResult::New());
+    result->path = detail->path;
+    result->file_handle =
+        OpenFileHandleImpl(detail->path, detail->open_flags, &result->error);
+    results[i++] = std::move(result);
   }
-
-  if (base::DirectoryExists(path)) {
-    // We must not return directories as files. In the file abstraction, we can
-    // fetch raw file descriptors over mojo pipes, and passing a file
-    // descriptor to a directory is a sandbox escape on Windows.
-    callback.Run(FileError::NOT_A_FILE, ScopedHandle());
-    return;
-  }
-
-  base::File base_file(path, open_flags);
-  if (!base_file.IsValid()) {
-    callback.Run(GetError(base_file), ScopedHandle());
-    return;
-  }
-
-  MojoHandle mojo_handle;
-  MojoResult create_result = MojoCreatePlatformHandleWrapper(
-      base_file.TakePlatformFile(), &mojo_handle);
-  if (create_result != MOJO_RESULT_OK) {
-    callback.Run(FileError::FAILED, ScopedHandle());
-    return;
-  }
-
-  callback.Run(FileError::OK, ScopedHandle(mojo::Handle(mojo_handle)));
+  callback.Run(std::move(results));
 }
 
 void DirectoryImpl::OpenDirectory(const mojo::String& raw_path,
                                   mojo::InterfaceRequest<Directory> directory,
                                   uint32_t open_flags,
                                   const OpenDirectoryCallback& callback) {
   base::FilePath path;
   FileError error = ValidatePath(raw_path, directory_path_, &path);
   if (error != FileError::OK) {
     callback.Run(error);
@@ skipping 198 matching lines @@
     if (base_file.Write(0, reinterpret_cast<char*>(&data.front()),
                         data_size) == -1) {
       callback.Run(GetError(base_file));
       return;
     }
   }
 
   callback.Run(FileError::OK);
 }
 
+mojo::ScopedHandle DirectoryImpl::OpenFileHandleImpl(
+    const mojo::String& raw_path,
+    uint32_t open_flags,
+    FileError* error) {
+  base::FilePath path;
+  *error = ValidatePath(raw_path, directory_path_, &path);
+  if (*error != FileError::OK)
+    return mojo::ScopedHandle();
+
+  if (base::DirectoryExists(path)) {
+    // We must not return directories as files. In the file abstraction, we
+    // can fetch raw file descriptors over mojo pipes, and passing a file
+    // descriptor to a directory is a sandbox escape on Windows.
+    *error = FileError::NOT_A_FILE;
+    return mojo::ScopedHandle();
+  }
+
+  base::File base_file(path, open_flags);
+  if (!base_file.IsValid()) {
+    *error = GetError(base_file);
+    return mojo::ScopedHandle();
+  }
+
+  MojoHandle mojo_handle;
+  MojoResult create_result = MojoCreatePlatformHandleWrapper(
+      base_file.TakePlatformFile(), &mojo_handle);
+  if (create_result != MOJO_RESULT_OK) {
+    *error = FileError::FAILED;
+    return mojo::ScopedHandle();
+  }
+
+  *error = FileError::OK;
+  return mojo::ScopedHandle(mojo::Handle(mojo_handle));
+}
+
 }  // namespace filesystem