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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
|
// Copyright (c) 2012 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.
#ifndef WEBKIT_FILEAPI_FILE_SYSTEM_CONTEXT_H_
#define WEBKIT_FILEAPI_FILE_SYSTEM_CONTEXT_H_
#include <map>
#include <string>
#include <vector>
#include "base/callback.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/platform_file.h"
#include "base/sequenced_task_runner_helpers.h"
#include "webkit/fileapi/file_system_types.h"
#include "webkit/fileapi/file_system_url.h"
#include "webkit/fileapi/task_runner_bound_observer_list.h"
#include "webkit/storage/webkit_storage_export.h"
namespace base {
class FilePath;
}
namespace quota {
class QuotaManagerProxy;
class SpecialStoragePolicy;
}
namespace webkit_blob {
class BlobURLRequestJobTest;
class FileStreamReader;
}
namespace fileapi {
class AsyncFileUtil;
class ExternalFileSystemMountPointProvider;
class ExternalMountPoints;
class FileSystemFileUtil;
class FileSystemMountPointProvider;
class FileSystemOperation;
class FileSystemOptions;
class FileSystemQuotaUtil;
class FileSystemTaskRunners;
class FileSystemURL;
class IsolatedMountPointProvider;
class LocalFileChangeTracker;
class LocalFileSyncContext;
class MountPoints;
class SandboxMountPointProvider;
struct DefaultContextDeleter;
// This class keeps and provides a file system context for FileSystem API.
// An instance of this class is created and owned by profile.
class WEBKIT_STORAGE_EXPORT FileSystemContext
: public base::RefCountedThreadSafe<FileSystemContext,
DefaultContextDeleter> {
public:
// task_runners->file_task_runner() is used as default TaskRunner.
// Unless a MountPointProvider is overridden in CreateFileSystemOperation,
// it is used for all file operations and file related meta operations.
// The code assumes that
// task_runners->file_task_runner()->RunsTasksOnCurrentThread()
// returns false if the current task is not running on the thread that allows
// blocking file operations (like SequencedWorkerPool implementation does).
//
// |external_mount_points| contains non-system external mount points available
// in the context. If not NULL, it will be used during URL cracking. On
// ChromeOS, it will be passed to external_mount_point_provider.
// |external_mount_points| may be NULL only on platforms different from
// ChromeOS (i.e. platforms that don't use external_mount_point_provider).
FileSystemContext(
scoped_ptr<FileSystemTaskRunners> task_runners,
ExternalMountPoints* external_mount_points,
quota::SpecialStoragePolicy* special_storage_policy,
quota::QuotaManagerProxy* quota_manager_proxy,
const base::FilePath& partition_path,
const FileSystemOptions& options);
bool DeleteDataForOriginOnFileThread(const GURL& origin_url);
quota::QuotaManagerProxy* quota_manager_proxy() const {
return quota_manager_proxy_.get();
}
// Returns a quota util for a given filesystem type. This may
// return NULL if the type does not support the usage tracking or
// it is not a quota-managed storage.
FileSystemQuotaUtil* GetQuotaUtil(FileSystemType type) const;
// Returns the appropriate AsyncFileUtil instance for the given |type|.
AsyncFileUtil* GetAsyncFileUtil(FileSystemType type) const;
// Returns the mount point provider instance for the given |type|.
// This may return NULL if it is given an invalid or unsupported filesystem
// type.
FileSystemMountPointProvider* GetMountPointProvider(
FileSystemType type) const;
// Returns update observers for the given filesystem type.
const UpdateObserverList* GetUpdateObservers(FileSystemType type) const;
// Returns a FileSystemMountPointProvider instance for sandboxed filesystem
// types (e.g. TEMPORARY or PERSISTENT). This is equivalent to calling
// GetMountPointProvider(kFileSystemType{Temporary, Persistent}).
SandboxMountPointProvider* sandbox_provider() const;
// Returns a FileSystemMountPointProvider instance for external filesystem
// type, which is used only by chromeos for now. This is equivalent to
// calling GetMountPointProvider(kFileSystemTypeExternal).
ExternalFileSystemMountPointProvider* external_provider() const;
// Used for OpenFileSystem.
typedef base::Callback<void(base::PlatformFileError result,
const std::string& name,
const GURL& root)> OpenFileSystemCallback;
// Used for DeleteFileSystem.
typedef base::Callback<void(base::PlatformFileError result)>
DeleteFileSystemCallback;
// Opens the filesystem for the given |origin_url| and |type|, and dispatches
// |callback| on completion.
// If |create| is true this may actually set up a filesystem instance
// (e.g. by creating the root directory or initializing the database
// entry etc).
void OpenFileSystem(
const GURL& origin_url,
FileSystemType type,
bool create,
const OpenFileSystemCallback& callback);
// Opens a syncable filesystem for the given |origin_url|.
// The file system is internally mounted as an external file system at the
// given |mount_name|.
// Currently only kFileSystemTypeSyncable type is supported.
void OpenSyncableFileSystem(
const std::string& mount_name,
const GURL& origin_url,
FileSystemType type,
bool create,
const OpenFileSystemCallback& callback);
// Deletes the filesystem for the given |origin_url| and |type|. This should
// be called on the IO Thread.
void DeleteFileSystem(
const GURL& origin_url,
FileSystemType type,
const DeleteFileSystemCallback& callback);
// Creates a new FileSystemOperation instance by getting an appropriate
// MountPointProvider for |url| and calling the provider's corresponding
// CreateFileSystemOperation method.
// The resolved MountPointProvider could perform further specialization
// depending on the filesystem type pointed by the |url|.
FileSystemOperation* CreateFileSystemOperation(
const FileSystemURL& url,
base::PlatformFileError* error_code);
// Creates new FileStreamReader instance to read a file pointed by the given
// filesystem URL |url| starting from |offset|. |expected_modification_time|
// specifies the expected last modification if the value is non-null, the
// reader will check the underlying file's actual modification time to see if
// the file has been modified, and if it does any succeeding read operations
// should fail with ERR_UPLOAD_FILE_CHANGED error.
// This method internally cracks the |url|, get an appropriate
// MountPointProvider for the URL and call the provider's CreateFileReader.
// The resolved MountPointProvider could perform further specialization
// depending on the filesystem type pointed by the |url|.
webkit_blob::FileStreamReader* CreateFileStreamReader(
const FileSystemURL& url,
int64 offset,
const base::Time& expected_modification_time);
// Register a filesystem provider. The ownership of |provider| is
// transferred to this instance.
void RegisterMountPointProvider(FileSystemType type,
FileSystemMountPointProvider* provider);
FileSystemTaskRunners* task_runners() { return task_runners_.get(); }
LocalFileChangeTracker* change_tracker() { return change_tracker_.get(); }
void SetLocalFileChangeTracker(scoped_ptr<LocalFileChangeTracker> tracker);
LocalFileSyncContext* sync_context() { return sync_context_.get(); }
void set_sync_context(LocalFileSyncContext* sync_context);
const base::FilePath& partition_path() const { return partition_path_; }
// Same as |CrackFileSystemURL|, but cracks FileSystemURL created from |url|.
FileSystemURL CrackURL(const GURL& url) const;
// Same as |CrackFileSystemURL|, but cracks FileSystemURL created from method
// arguments.
FileSystemURL CreateCrackedFileSystemURL(const GURL& origin,
FileSystemType type,
const base::FilePath& path) const;
private:
// Friended for GetFileUtil.
// These classes know the target filesystem (i.e. sandbox filesystem)
// supports synchronous FileUtil.
friend class LocalFileSystemOperation;
friend class LocalFileChangeTracker;
friend class LocalFileSyncContext;
// Friended for GetFileUtil.
// Test classes that rely on synchronous FileUtils.
friend class webkit_blob::BlobURLRequestJobTest;
friend class FileSystemQuotaClientTest;
friend class LocalFileSystemTestOriginHelper;
friend class NativeMediaFileUtilTest;
friend class FileSystemURLRequestJobTest;
friend class UploadFileSystemFileElementReaderTest;
// Deleters.
friend struct DefaultContextDeleter;
friend class base::DeleteHelper<FileSystemContext>;
friend class base::RefCountedThreadSafe<FileSystemContext,
DefaultContextDeleter>;
~FileSystemContext();
void DeleteOnCorrectThread() const;
// For non-cracked isolated and external mount points, returns a FileSystemURL
// created by cracking |url|. The url is cracked using MountPoints registered
// as |url_crackers_|. If the url cannot be cracked, returns invalid
// FileSystemURL.
//
// If the original url does not point to an isolated or external filesystem,
// returns the original url, without attempting to crack it.
FileSystemURL CrackFileSystemURL(const FileSystemURL& url) const;
// Returns the appropriate FileUtil instance for the given |type|.
// This may return NULL if it is given an invalid type or the filesystem
// does not support synchronous file operations.
FileSystemFileUtil* GetFileUtil(FileSystemType type) const;
scoped_ptr<FileSystemTaskRunners> task_runners_;
scoped_refptr<quota::QuotaManagerProxy> quota_manager_proxy_;
// Regular mount point providers.
scoped_ptr<SandboxMountPointProvider> sandbox_provider_;
scoped_ptr<IsolatedMountPointProvider> isolated_provider_;
scoped_ptr<ExternalFileSystemMountPointProvider> external_provider_;
// Registered mount point providers.
std::map<FileSystemType, FileSystemMountPointProvider*> provider_map_;
// External mount points visible in the file system context (excluding system
// external mount points).
scoped_refptr<ExternalMountPoints> external_mount_points_;
// MountPoints used to crack FileSystemURLs. The MountPoints are ordered
// in order they should try to crack a FileSystemURL.
std::vector<MountPoints*> url_crackers_;
// The base path of the storage partition for this context.
const base::FilePath partition_path_;
// For syncable file systems.
scoped_ptr<LocalFileChangeTracker> change_tracker_;
scoped_refptr<LocalFileSyncContext> sync_context_;
DISALLOW_IMPLICIT_CONSTRUCTORS(FileSystemContext);
};
struct DefaultContextDeleter {
static void Destruct(const FileSystemContext* context) {
context->DeleteOnCorrectThread();
}
};
} // namespace fileapi
#endif // WEBKIT_FILEAPI_FILE_SYSTEM_CONTEXT_H_
|