| // Copyright 2018 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 "content/browser/native_file_system/native_file_system_file_handle_impl.h" |
| |
| #include <limits> |
| #include "base/bind.h" |
| #include "base/bind_helpers.h" |
| #include "base/files/scoped_temp_dir.h" |
| #include "base/guid.h" |
| #include "base/test/bind_test_util.h" |
| #include "base/test/scoped_feature_list.h" |
| #include "base/test/scoped_task_environment.h" |
| #include "content/public/test/test_browser_thread_bundle.h" |
| #include "mojo/public/cpp/system/string_data_pipe_producer.h" |
| #include "net/base/io_buffer.h" |
| #include "net/base/net_errors.h" |
| #include "net/base/test_completion_callback.h" |
| #include "storage/browser/blob/blob_data_builder.h" |
| #include "storage/browser/blob/blob_impl.h" |
| #include "storage/browser/blob/blob_storage_context.h" |
| #include "storage/browser/fileapi/file_stream_reader.h" |
| #include "storage/browser/test/async_file_test_helper.h" |
| #include "storage/browser/test/test_file_system_context.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "third_party/blink/public/common/features.h" |
| |
| using storage::FileSystemURL; |
| |
| namespace content { |
| |
| class NativeFileSystemFileHandleImplTest : public testing::Test { |
| public: |
| NativeFileSystemFileHandleImplTest() |
| : scoped_task_environment_( |
| base::test::ScopedTaskEnvironment::MainThreadType::IO) { |
| scoped_feature_list_.InitAndEnableFeature( |
| blink::features::kNativeFileSystemAPI); |
| } |
| |
| void SetUp() override { |
| ASSERT_TRUE(dir_.CreateUniqueTempDir()); |
| file_system_context_ = CreateFileSystemContextForTesting( |
| /*quota_manager_proxy=*/nullptr, dir_.GetPath()); |
| |
| test_url_ = file_system_context_->CreateCrackedFileSystemURL( |
| GURL("http://example.com"), storage::kFileSystemTypeTest, |
| base::FilePath::FromUTF8Unsafe("test")); |
| |
| ASSERT_EQ(base::File::FILE_OK, AsyncFileTestHelper::CreateFile( |
| file_system_context_.get(), test_url_)); |
| |
| chrome_blob_context_ = base::MakeRefCounted<ChromeBlobStorageContext>(); |
| chrome_blob_context_->InitializeOnIOThread(base::FilePath(), nullptr); |
| blob_context_ = chrome_blob_context_->context(); |
| |
| manager_ = base::MakeRefCounted<NativeFileSystemManagerImpl>( |
| file_system_context_, chrome_blob_context_); |
| |
| handle_ = std::make_unique<NativeFileSystemFileHandleImpl>(manager_.get(), |
| test_url_); |
| } |
| |
| blink::mojom::BlobPtr CreateBlob(const std::string& contents) { |
| auto builder = |
| std::make_unique<storage::BlobDataBuilder>(base::GenerateGUID()); |
| builder->AppendData(contents); |
| auto handle = blob_context_->AddFinishedBlob(std::move(builder)); |
| blink::mojom::BlobPtr result; |
| storage::BlobImpl::Create(std::move(handle), MakeRequest(&result)); |
| return result; |
| } |
| |
| mojo::ScopedDataPipeConsumerHandle CreateStream(const std::string& contents) { |
| // Test with a relatively low capacity pipe to make sure it isn't all |
| // written/read in one go. |
| mojo::ScopedDataPipeProducerHandle producer_handle; |
| mojo::ScopedDataPipeConsumerHandle consumer_handle; |
| MojoCreateDataPipeOptions options; |
| options.struct_size = sizeof(MojoCreateDataPipeOptions); |
| options.flags = MOJO_CREATE_DATA_PIPE_FLAG_NONE; |
| options.element_num_bytes = 1; |
| options.capacity_num_bytes = 16; |
| mojo::CreateDataPipe(&options, &producer_handle, &consumer_handle); |
| CHECK(producer_handle.is_valid()); |
| auto producer = std::make_unique<mojo::StringDataPipeProducer>( |
| std::move(producer_handle)); |
| auto* producer_raw = producer.get(); |
| producer_raw->Write( |
| contents, |
| mojo::StringDataPipeProducer::AsyncWritingMode:: |
| STRING_MAY_BE_INVALIDATED_BEFORE_COMPLETION, |
| base::BindOnce( |
| base::DoNothing::Once<std::unique_ptr<mojo::StringDataPipeProducer>, |
| MojoResult>(), |
| std::move(producer))); |
| return consumer_handle; |
| } |
| |
| std::string ReadFile(const FileSystemURL& url) { |
| std::unique_ptr<storage::FileStreamReader> reader = |
| file_system_context_->CreateFileStreamReader( |
| url, 0, std::numeric_limits<int64_t>::max(), base::Time()); |
| std::string result; |
| while (true) { |
| auto buf = base::MakeRefCounted<net::IOBufferWithSize>(4096); |
| net::TestCompletionCallback callback; |
| int rv = reader->Read(buf.get(), buf->size(), callback.callback()); |
| if (rv == net::ERR_IO_PENDING) |
| rv = callback.WaitForResult(); |
| EXPECT_GE(rv, 0); |
| if (rv < 0) |
| return "(read failure)"; |
| if (rv == 0) |
| return result; |
| result.append(buf->data(), rv); |
| } |
| } |
| |
| base::File::Error WriteBlobSync(uint64_t position, |
| blink::mojom::BlobPtr blob, |
| uint64_t* bytes_written_out) { |
| base::RunLoop loop; |
| base::File::Error result_out; |
| handle_->Write(position, std::move(blob), |
| base::BindLambdaForTesting( |
| [&](blink::mojom::NativeFileSystemErrorPtr result, |
| uint64_t bytes_written) { |
| result_out = result->error_code; |
| *bytes_written_out = bytes_written; |
| loop.Quit(); |
| })); |
| loop.Run(); |
| return result_out; |
| } |
| |
| base::File::Error WriteStreamSync( |
| uint64_t position, |
| mojo::ScopedDataPipeConsumerHandle data_pipe, |
| uint64_t* bytes_written_out) { |
| base::RunLoop loop; |
| base::File::Error result_out; |
| handle_->WriteStream(position, std::move(data_pipe), |
| base::BindLambdaForTesting( |
| [&](blink::mojom::NativeFileSystemErrorPtr result, |
| uint64_t bytes_written) { |
| result_out = result->error_code; |
| *bytes_written_out = bytes_written; |
| loop.Quit(); |
| })); |
| loop.Run(); |
| return result_out; |
| } |
| |
| base::File::Error TruncateSync(uint64_t length) { |
| base::RunLoop loop; |
| base::File::Error result_out; |
| handle_->Truncate(length, |
| base::BindLambdaForTesting( |
| [&](blink::mojom::NativeFileSystemErrorPtr result) { |
| result_out = result->error_code; |
| loop.Quit(); |
| })); |
| loop.Run(); |
| return result_out; |
| } |
| |
| virtual bool WriteUsingBlobs() { return true; } |
| |
| base::File::Error WriteSync(uint64_t position, |
| const std::string& contents, |
| uint64_t* bytes_written_out) { |
| if (WriteUsingBlobs()) |
| return WriteBlobSync(position, CreateBlob(contents), bytes_written_out); |
| return WriteStreamSync(position, CreateStream(contents), bytes_written_out); |
| } |
| |
| protected: |
| base::test::ScopedFeatureList scoped_feature_list_; |
| TestBrowserThreadBundle scoped_task_environment_; |
| |
| base::ScopedTempDir dir_; |
| scoped_refptr<storage::FileSystemContext> file_system_context_; |
| scoped_refptr<ChromeBlobStorageContext> chrome_blob_context_; |
| storage::BlobStorageContext* blob_context_; |
| scoped_refptr<NativeFileSystemManagerImpl> manager_; |
| |
| FileSystemURL test_url_; |
| |
| std::unique_ptr<NativeFileSystemFileHandleImpl> handle_; |
| }; |
| |
| class NativeFileSystemFileHandleImplWriteTest |
| : public NativeFileSystemFileHandleImplTest, |
| public testing::WithParamInterface<bool> { |
| public: |
| bool WriteUsingBlobs() override { return GetParam(); } |
| }; |
| |
| INSTANTIATE_TEST_SUITE_P(NativeFileSystemFileHandleImplTest, |
| NativeFileSystemFileHandleImplWriteTest, |
| ::testing::Bool()); |
| |
| TEST_F(NativeFileSystemFileHandleImplTest, WriteInvalidBlob) { |
| blink::mojom::BlobPtr blob; |
| MakeRequest(&blob); |
| |
| uint64_t bytes_written; |
| base::File::Error result = WriteBlobSync(0, std::move(blob), &bytes_written); |
| EXPECT_EQ(result, base::File::FILE_ERROR_FAILED); |
| EXPECT_EQ(bytes_written, 0u); |
| |
| EXPECT_EQ("", ReadFile(test_url_)); |
| } |
| |
| TEST_P(NativeFileSystemFileHandleImplWriteTest, WriteValidEmptyString) { |
| uint64_t bytes_written; |
| base::File::Error result = WriteSync(0, "", &bytes_written); |
| EXPECT_EQ(result, base::File::FILE_OK); |
| EXPECT_EQ(bytes_written, 0u); |
| |
| EXPECT_EQ("", ReadFile(test_url_)); |
| } |
| |
| TEST_P(NativeFileSystemFileHandleImplWriteTest, WriteValidNonEmpty) { |
| std::string test_data("abcdefghijklmnopqrstuvwxyz"); |
| uint64_t bytes_written; |
| base::File::Error result = WriteSync(0, test_data, &bytes_written); |
| EXPECT_EQ(result, base::File::FILE_OK); |
| EXPECT_EQ(bytes_written, test_data.size()); |
| |
| EXPECT_EQ(test_data, ReadFile(test_url_)); |
| } |
| |
| TEST_P(NativeFileSystemFileHandleImplWriteTest, WriteWithOffsetInFile) { |
| uint64_t bytes_written; |
| base::File::Error result; |
| |
| result = WriteSync(0, "1234567890", &bytes_written); |
| EXPECT_EQ(result, base::File::FILE_OK); |
| EXPECT_EQ(bytes_written, 10u); |
| |
| result = WriteSync(4, "abc", &bytes_written); |
| EXPECT_EQ(result, base::File::FILE_OK); |
| EXPECT_EQ(bytes_written, 3u); |
| |
| EXPECT_EQ("1234abc890", ReadFile(test_url_)); |
| } |
| |
| TEST_P(NativeFileSystemFileHandleImplWriteTest, WriteWithOffsetPastFile) { |
| uint64_t bytes_written; |
| base::File::Error result = WriteSync(4, "abc", &bytes_written); |
| EXPECT_EQ(result, base::File::FILE_ERROR_FAILED); |
| EXPECT_EQ(bytes_written, 0u); |
| |
| EXPECT_EQ("", ReadFile(test_url_)); |
| } |
| |
| TEST_F(NativeFileSystemFileHandleImplTest, TruncateShrink) { |
| uint64_t bytes_written; |
| base::File::Error result; |
| |
| result = WriteSync(0, "1234567890", &bytes_written); |
| EXPECT_EQ(result, base::File::FILE_OK); |
| EXPECT_EQ(bytes_written, 10u); |
| |
| result = TruncateSync(5); |
| EXPECT_EQ(result, base::File::FILE_OK); |
| |
| EXPECT_EQ("12345", ReadFile(test_url_)); |
| } |
| |
| TEST_F(NativeFileSystemFileHandleImplTest, TruncateGrow) { |
| uint64_t bytes_written; |
| base::File::Error result; |
| |
| result = WriteSync(0, "abc", &bytes_written); |
| EXPECT_EQ(result, base::File::FILE_OK); |
| EXPECT_EQ(bytes_written, 3u); |
| |
| result = TruncateSync(5); |
| EXPECT_EQ(result, base::File::FILE_OK); |
| |
| EXPECT_EQ(std::string("abc\0\0", 5), ReadFile(test_url_)); |
| } |
| |
| // TODO(mek): More tests, particularly for error conditions. |
| |
| } // namespace content |