Replace base::File wrapping with typemapping.

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/public/cpp/bindings/strong_binding.h"
-#include "mojo/public/cpp/system/platform_handle.h"
 
 namespace filesystem {
 
 DirectoryImpl::DirectoryImpl(base::FilePath directory_path,
                              scoped_refptr<SharedTempDir> temp_dir,
                              scoped_refptr<LockTable> lock_table)
     : directory_path_(directory_path),
       temp_dir_(std::move(temp_dir)),
       lock_table_(std::move(lock_table)) {}
 
@@ skipping 54 matching lines @@
         base::MakeUnique<FileImpl>(path, std::move(base_file), temp_dir_,
                                    lock_table_),
         std::move(file));
   }
   callback.Run(mojom::FileError::OK);
 }
 
 void DirectoryImpl::OpenFileHandle(const std::string& raw_path,
                                    uint32_t open_flags,
                                    const OpenFileHandleCallback& callback) {
-  mojom::FileError error = mojom::FileError::OK;
-  mojo::ScopedHandle handle = OpenFileHandleImpl(raw_path, open_flags, &error);
-  callback.Run(error, std::move(handle));
+  base::File file = OpenFileHandleImpl(raw_path, open_flags);
+  mojom::FileError error = GetError(file);
+  callback.Run(error, std::move(file));
 }
 
 void DirectoryImpl::OpenFileHandles(
     std::vector<mojom::FileOpenDetailsPtr> details,
     const OpenFileHandlesCallback& callback) {
   std::vector<mojom::FileOpenResultPtr> results(details.size());
   size_t i = 0;
   for (const auto& detail : details) {
     mojom::FileOpenResultPtr result(mojom::FileOpenResult::New());
     result->path = detail->path;
-    result->file_handle =
-        OpenFileHandleImpl(detail->path, detail->open_flags, &result->error);
+    result->file_handle = OpenFileHandleImpl(detail->path, detail->open_flags);
+    result->error = GetError(result->file_handle);
     results[i++] = std::move(result);
   }
   callback.Run(std::move(results));
 }
 
 void DirectoryImpl::OpenDirectory(const std::string& raw_path,
                                   mojom::DirectoryRequest directory,
                                   uint32_t open_flags,
                                   const OpenDirectoryCallback& callback) {
   base::FilePath path;
@@ skipping 208 matching lines @@
     if (base_file.Write(0, reinterpret_cast<const char*>(&data.front()),
                         data_size) == -1) {
       callback.Run(GetError(base_file));
       return;
     }
   }
 
   callback.Run(mojom::FileError::OK);
 }
 
-mojo::ScopedHandle DirectoryImpl::OpenFileHandleImpl(
-    const std::string& raw_path,
-    uint32_t open_flags,
-    mojom::FileError* error) {
+base::File DirectoryImpl::OpenFileHandleImpl(const std::string& raw_path,
+                                             uint32_t open_flags) {
   base::FilePath path;
-  *error = ValidatePath(raw_path, directory_path_, &path);
-  if (*error != mojom::FileError::OK)
-    return mojo::ScopedHandle();
+  mojom::FileError error = ValidatePath(raw_path, directory_path_, &path);
+  if (error != mojom::FileError::OK)
+    return base::File(static_cast<base::File::Error>(error));

[dcheng, 2016/12/05 19:33:04]

This is a little ugly. Maybe we can/should just typemap this so it Just Works in
the future?

[Sam McNally, 2016/12/06 23:15:18]

Acknowledged.

 
   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 = mojom::FileError::NOT_A_FILE;
-    return mojo::ScopedHandle();
+    return base::File(base::File::FILE_ERROR_NOT_A_FILE);
   }
 
-  base::File base_file(path, open_flags);
-  if (!base_file.IsValid()) {
-    *error = GetError(base_file);
-    return mojo::ScopedHandle();
-  }
-
-  *error = mojom::FileError::OK;
-  return mojo::WrapPlatformFile(base_file.TakePlatformFile());
+  return base::File(path, open_flags);
 }
 
 }  // namespace filesystem