async_file_test_helper.cc | Explore in Territory

// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "storage/browser/test/async_file_test_helper.h"

#include <memory>
#include <utility>

#include "base/files/file_util.h"
#include "base/files/scoped_temp_dir.h"
#include "base/functional/bind.h"
#include "base/run_loop.h"
#include "base/task/sequenced_task_runner.h"
#include "storage/browser/blob/shareable_file_reference.h"
#include "storage/browser/file_system/copy_or_move_hook_delegate.h"
#include "storage/browser/file_system/file_system_backend.h"
#include "storage/browser/file_system/file_system_context.h"
#include "storage/browser/file_system/file_system_operation_runner.h"
#include "storage/browser/file_system/file_system_url.h"
#include "storage/browser/file_system/file_system_util.h"
#include "storage/browser/quota/quota_manager.h"
#include "storage/browser/quota/quota_manager_proxy.h"
#include "storage/common/file_system/file_system_util.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/blink/public/common/storage_key/storage_key.h"

namespace storage {

FileEntryList;

namespace {

void AssignAndQuit(base::RunLoop* run_loop,
                   base::File::Error* result_out,
                   base::File::Error result) { … }

base::OnceCallback<void(base::File::Error)> AssignAndQuitCallback(
    base::RunLoop* run_loop,
    base::File::Error* result) { … }

void GetMetadataCallback(base::RunLoop* run_loop,
                         base::File::Error* result_out,
                         base::File::Info* file_info_out,
                         base::File::Error result,
                         const base::File::Info& file_info) { … }

void CreateSnapshotFileCallback(
    base::RunLoop* run_loop,
    base::File::Error* result_out,
    base::FilePath* platform_path_out,
    base::File::Error result,
    const base::File::Info& file_info,
    const base::FilePath& platform_path,
    scoped_refptr<ShareableFileReference> file_ref) { … }

void ReadDirectoryCallback(base::RunLoop* run_loop,
                           base::File::Error* result_out,
                           FileEntryList* entries_out,
                           base::File::Error result,
                           FileEntryList entries,
                           bool has_more) { … }

void DidGetUsageAndQuota(blink::mojom::QuotaStatusCode* status_out,
                         int64_t* usage_out,
                         int64_t* quota_out,
                         base::OnceClosure done_callback,
                         blink::mojom::QuotaStatusCode status,
                         int64_t usage,
                         int64_t quota) { … }

}  // namespace

const int64_t AsyncFileTestHelper::kDontCheckSize = …;

base::File::Error AsyncFileTestHelper::Copy(FileSystemContext* context,
                                            const FileSystemURL& src,
                                            const FileSystemURL& dest) { … }

base::File::Error AsyncFileTestHelper::CopyWithHookDelegate(
    FileSystemContext* context,
    const FileSystemURL& src,
    const FileSystemURL& dest,
    FileSystemOperation::ErrorBehavior error_behavior,
    std::unique_ptr<CopyOrMoveHookDelegate> copy_or_move_hook_delegate) { … }

base::File::Error AsyncFileTestHelper::CopyFileLocal(
    FileSystemContext* context,
    const FileSystemURL& src,
    const FileSystemURL& dest) { … }

base::File::Error AsyncFileTestHelper::Move(FileSystemContext* context,
                                            const FileSystemURL& src,
                                            const FileSystemURL& dest) { … }

base::File::Error AsyncFileTestHelper::MoveWithHookDelegate(
    FileSystemContext* context,
    const FileSystemURL& src,
    const FileSystemURL& dest,
    FileSystemOperation::ErrorBehavior error_behavior,
    std::unique_ptr<CopyOrMoveHookDelegate> copy_or_move_hook_delegate) { … }

base::File::Error AsyncFileTestHelper::MoveFileLocal(
    FileSystemContext* context,
    const FileSystemURL& src,
    const FileSystemURL& dest) { … }

base::File::Error AsyncFileTestHelper::Remove(FileSystemContext* context,
                                              const FileSystemURL& url,
                                              bool recursive) { … }

base::File::Error AsyncFileTestHelper::ReadDirectory(FileSystemContext* context,
                                                     const FileSystemURL& url,
                                                     FileEntryList* entries) { … }

base::File::Error AsyncFileTestHelper::CreateDirectory(
    FileSystemContext* context,
    const FileSystemURL& url) { … }

base::File::Error AsyncFileTestHelper::CreateFile(FileSystemContext* context,
                                                  const FileSystemURL& url) { … }

base::File::Error AsyncFileTestHelper::CreateFileWithData(
    FileSystemContext* context,
    const FileSystemURL& url,
    std::string_view data) { … }

base::File::Error AsyncFileTestHelper::TruncateFile(FileSystemContext* context,
                                                    const FileSystemURL& url,
                                                    size_t size) { … }

base::File::Error AsyncFileTestHelper::GetMetadata(
    FileSystemContext* context,
    const FileSystemURL& url,
    base::File::Info* file_info) { … }

base::File::Error AsyncFileTestHelper::GetPlatformPath(
    FileSystemContext* context,
    const FileSystemURL& url,
    base::FilePath* platform_path) { … }

bool AsyncFileTestHelper::FileExists(FileSystemContext* context,
                                     const FileSystemURL& url,
                                     int64_t expected_size) { … }

bool AsyncFileTestHelper::DirectoryExists(FileSystemContext* context,
                                          const FileSystemURL& url) { … }

blink::mojom::QuotaStatusCode AsyncFileTestHelper::GetUsageAndQuota(
    QuotaManagerProxy* quota_manager_proxy,
    const blink::StorageKey& storage_key,
    FileSystemType type,
    int64_t* usage,
    int64_t* quota) { … }

base::File::Error AsyncFileTestHelper::TouchFile(
    FileSystemContext* context,
    const FileSystemURL& url,
    const base::Time& last_access_time,
    const base::Time& last_modified_time) { … }

}  // namespace storage
chromium/storage/browser/test/async_file_test_helper.cc
