mojo: Fix leveldb unittests by making fs::Directories cloneable.

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,
-                             std::unique_ptr<base::ScopedTempDir> temp_dir,
+                             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)) {}
 
-DirectoryImpl::~DirectoryImpl() {
-}
+DirectoryImpl::~DirectoryImpl() {}
 
 void DirectoryImpl::Read(const ReadCallback& callback) {
   mojo::Array<DirectoryEntryPtr> entries;
   base::FileEnumerator directory_enumerator(
       directory_path_, false,
       base::FileEnumerator::DIRECTORIES | base::FileEnumerator::FILES);
   for (base::FilePath name = directory_enumerator.Next(); !name.empty();
        name = directory_enumerator.Next()) {
     base::FileEnumerator::FileInfo info = directory_enumerator.GetInfo();
     DirectoryEntryPtr entry = DirectoryEntry::New();
@@ skipping 30 matching lines @@
     return;
   }
 
   base::File base_file(path, open_flags);
   if (!base_file.IsValid()) {
     callback.Run(GetError(base_file));
     return;
   }
 
   if (file.is_pending()) {
-    new FileImpl(std::move(file), path, std::move(base_file), lock_table_);
+    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) {
@@ skipping 51 matching lines @@
     }
 
     base::File::Error error;
     if (!base::CreateDirectoryAndGetError(path, &error)) {
       callback.Run(static_cast<filesystem::FileError>(error));
       return;
     }
   }
 
   if (directory.is_pending())
-    new DirectoryImpl(std::move(directory), path, nullptr, lock_table_);
+    new DirectoryImpl(std::move(directory), path, temp_dir_, lock_table_);
   callback.Run(FileError::OK);
 }
 
 void DirectoryImpl::Rename(const mojo::String& raw_old_path,
                            const mojo::String& raw_new_path,
                            const RenameCallback& callback) {
   base::FilePath old_path;
   FileError error = ValidatePath(raw_old_path, directory_path_, &old_path);
   if (error != FileError::OK) {
     callback.Run(error);
@@ skipping 91 matching lines @@
 
   base::File::Info info;
   if (!base_file.GetInfo(&info)) {
     callback.Run(FileError::FAILED, nullptr);
     return;
   }
 
   callback.Run(FileError::OK, MakeFileInformation(info));
 }
 
+void DirectoryImpl::Clone(mojo::InterfaceRequest<Directory> directory) {
+  if (directory.is_pending()) {
+    new DirectoryImpl(std::move(directory), directory_path_,
+                      temp_dir_, lock_table_);
+  }
+}
+
 void DirectoryImpl::ReadEntireFile(const mojo::String& raw_path,
                                    const ReadEntireFileCallback& callback) {
   base::FilePath path;
   FileError error = ValidatePath(raw_path, directory_path_, &path);
   if (error != FileError::OK) {
     callback.Run(error, mojo::Array<uint8_t>());
     return;
   }
 
   if (base::DirectoryExists(path)) {
@@ skipping 46 matching lines @@
                         data_size) == -1) {
       callback.Run(GetError(base_file));
       return;
     }
   }
 
   callback.Run(FileError::OK);
 }
 
 }  // namespace filesystem