1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
|
// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef STORAGE_BROWSER_TEST_SANDBOX_FILE_SYSTEM_TEST_HELPER_H_
#define STORAGE_BROWSER_TEST_SANDBOX_FILE_SYSTEM_TEST_HELPER_H_
#include <stdint.h>
#include <string>
#include "base/files/file_error_or.h"
#include "base/files/file_path.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/scoped_refptr.h"
#include "storage/browser/file_system/file_system_url.h"
#include "storage/browser/file_system/file_system_usage_cache.h"
#include "storage/browser/file_system/task_runner_bound_observer_list.h"
#include "storage/common/file_system/file_system_types.h"
#include "storage/common/file_system/file_system_util.h"
namespace base {
class FilePath;
} // namespace base
namespace blink {
class StorageKey;
} // namespace blink
namespace storage {
class FileSystemContext;
class FileSystemFileUtil;
class FileSystemOperationContext;
class FileSystemOperationRunner;
class ObfuscatedFileUtilDelegate;
class QuotaManagerProxy;
} // namespace storage
namespace storage {
// Filesystem test helper class that encapsulates test environment for
// a given {StorageKey, (optional) BucketLocator, type} pair. This helper only
// works for sandboxed file systems (Temporary or Persistent).
class SandboxFileSystemTestHelper {
public:
SandboxFileSystemTestHelper(const blink::StorageKey& storage_key,
FileSystemType type);
SandboxFileSystemTestHelper();
~SandboxFileSystemTestHelper();
void SetUp(const base::FilePath& base_dir);
// If you want to use more than one SandboxFileSystemTestHelper in
// a single base directory, they have to share a context, so that they don't
// have multiple databases fighting over the lock to the origin directory
// [deep down inside ObfuscatedFileUtil].
void SetUp(scoped_refptr<FileSystemContext> file_system_context);
void SetUp(scoped_refptr<FileSystemContext> file_system_context,
const BucketLocator& bucket_locator);
void SetUp(const base::FilePath& base_dir,
scoped_refptr<QuotaManagerProxy> quota_manager_proxy);
void TearDown();
base::FilePath GetRootPath();
base::FilePath GetLocalPath(const base::FilePath& path);
base::FilePath GetLocalPathFromASCII(const std::string& path);
// Returns empty path if filesystem type is neither temporary nor persistent.
base::FileErrorOr<base::FilePath> GetUsageCachePath() const;
FileSystemURL CreateURL(const base::FilePath& path) const;
FileSystemURL CreateURLFromUTF8(const std::string& utf8) const {
return CreateURL(base::FilePath::FromUTF8Unsafe(utf8));
}
// This returns cached usage size returned by QuotaUtil.
int64_t GetCachedUsage() const;
// This doesn't work with OFSFU.
int64_t ComputeCurrentStorageKeyUsage();
int64_t ComputeCurrentDirectoryDatabaseUsage();
FileSystemOperationRunner* operation_runner();
std::unique_ptr<FileSystemOperationContext> NewOperationContext();
void AddFileChangeObserver(FileChangeObserver* observer);
void AddFileUpdateObserver(FileUpdateObserver* observer);
FileSystemContext* file_system_context() const {
return file_system_context_.get();
}
const blink::StorageKey& storage_key() const {
return bucket_locator_.storage_key;
}
FileSystemType type() const { return type_; }
FileSystemFileUtil* file_util() const { return file_util_; }
FileSystemUsageCache* usage_cache();
ObfuscatedFileUtilDelegate* file_util_delegate();
private:
void SetUpFileSystem();
scoped_refptr<FileSystemContext> file_system_context_;
BucketLocator bucket_locator_;
const FileSystemType type_;
raw_ptr<FileSystemFileUtil, DanglingUntriaged> file_util_;
};
} // namespace storage
#endif // STORAGE_BROWSER_TEST_SANDBOX_FILE_SYSTEM_TEST_HELPER_H_
|
