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
|
// 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_BROWSER_FILEAPI_FILE_SYSTEM_BACKEND_H_
#define WEBKIT_BROWSER_FILEAPI_FILE_SYSTEM_BACKEND_H_
#include <string>
#include <vector>
#include "base/callback_forward.h"
#include "base/files/file.h"
#include "base/files/file_path.h"
#include "base/memory/scoped_ptr.h"
#include "webkit/browser/fileapi/file_permission_policy.h"
#include "webkit/browser/fileapi/open_file_system_mode.h"
#include "webkit/browser/webkit_storage_browser_export.h"
#include "webkit/common/fileapi/file_system_types.h"
class GURL;
namespace webkit_blob {
class FileStreamReader;
}
namespace fileapi {
class AsyncFileUtil;
class CopyOrMoveFileValidatorFactory;
class FileSystemURL;
class FileStreamWriter;
class FileSystemContext;
class FileSystemFileUtil;
class FileSystemOperation;
class FileSystemQuotaUtil;
// An interface for defining a file system backend.
//
// NOTE: when you implement a new FileSystemBackend for your own
// FileSystem module, please contact to kinuko@chromium.org.
//
class WEBKIT_STORAGE_BROWSER_EXPORT FileSystemBackend {
public:
// Callback for InitializeFileSystem.
typedef base::Callback<void(const GURL& root_url,
const std::string& name,
base::File::Error error)>
OpenFileSystemCallback;
virtual ~FileSystemBackend() {}
// Returns true if this filesystem backend can handle |type|.
// One filesystem backend may be able to handle multiple filesystem types.
virtual bool CanHandleType(FileSystemType type) const = 0;
// This method is called right after the backend is registered in the
// FileSystemContext and before any other methods are called. Each backend can
// do additional initialization which depends on FileSystemContext here.
virtual void Initialize(FileSystemContext* context) = 0;
// Resolves the filesystem root URL and the name for the given |url|.
// This verifies if it is allowed to request (or create) the filesystem and if
// it can access (or create) the root directory.
// If |mode| is CREATE_IF_NONEXISTENT calling this may also create the root
// directory (and/or related database entries etc) for the filesystem if it
// doesn't exist.
virtual void ResolveURL(const FileSystemURL& url,
OpenFileSystemMode mode,
const OpenFileSystemCallback& callback) = 0;
// Returns the specialized AsyncFileUtil for this backend.
virtual AsyncFileUtil* GetAsyncFileUtil(FileSystemType type) = 0;
// Returns the specialized CopyOrMoveFileValidatorFactory for this backend
// and |type|. If |error_code| is PLATFORM_FILE_OK and the result is NULL,
// then no validator is required.
virtual CopyOrMoveFileValidatorFactory* GetCopyOrMoveFileValidatorFactory(
FileSystemType type, base::File::Error* error_code) = 0;
// Returns a new instance of the specialized FileSystemOperation for this
// backend based on the given triplet of |origin_url|, |file_system_type|
// and |virtual_path|. On failure to create a file system operation, set
// |error_code| correspondingly.
// This method is usually dispatched by
// FileSystemContext::CreateFileSystemOperation.
virtual FileSystemOperation* CreateFileSystemOperation(
const FileSystemURL& url,
FileSystemContext* context,
base::File::Error* error_code) const = 0;
// Returns true if Blobs accessing |url| should use FileStreamReader.
// If false, Blobs are accessed using a snapshot file by calling
// AsyncFileUtil::CreateSnapshotFile.
virtual bool SupportsStreaming(const FileSystemURL& url) const = 0;
// Creates a new file stream reader for a given filesystem URL |url| with an
// offset |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 itself does *not* check if the given path exists and is a
// regular file.
virtual scoped_ptr<webkit_blob::FileStreamReader> CreateFileStreamReader(
const FileSystemURL& url,
int64 offset,
const base::Time& expected_modification_time,
FileSystemContext* context) const = 0;
// Creates a new file stream writer for a given filesystem URL |url| with an
// offset |offset|.
// This method itself does *not* check if the given path exists and is a
// regular file.
virtual scoped_ptr<FileStreamWriter> CreateFileStreamWriter(
const FileSystemURL& url,
int64 offset,
FileSystemContext* context) const = 0;
// Returns the specialized FileSystemQuotaUtil for this backend.
// This could return NULL if this backend does not support quota.
virtual FileSystemQuotaUtil* GetQuotaUtil() = 0;
};
// An interface to control external file system access permissions.
// TODO(satorux): Move this out of 'webkit/browser/fileapi'. crbug.com/257279
class ExternalFileSystemBackend : public FileSystemBackend {
public:
// Returns true if |url| is allowed to be accessed.
// This is supposed to perform ExternalFileSystem-specific security
// checks.
virtual bool IsAccessAllowed(const fileapi::FileSystemURL& url) const = 0;
// Returns the list of top level directories that are exposed by this
// provider. This list is used to set appropriate child process file access
// permissions.
virtual std::vector<base::FilePath> GetRootDirectories() const = 0;
// Grants access to all external file system from extension identified with
// |extension_id|.
virtual void GrantFullAccessToExtension(const std::string& extension_id) = 0;
// Grants access to |virtual_path| from |origin_url|.
virtual void GrantFileAccessToExtension(
const std::string& extension_id,
const base::FilePath& virtual_path) = 0;
// Revokes file access from extension identified with |extension_id|.
virtual void RevokeAccessForExtension(
const std::string& extension_id) = 0;
// Gets virtual path by known filesystem path. Returns false when filesystem
// path is not exposed by this provider.
virtual bool GetVirtualPath(const base::FilePath& file_system_path,
base::FilePath* virtual_path) = 0;
};
} // namespace fileapi
#endif // WEBKIT_BROWSER_FILEAPI_FILE_SYSTEM_BACKEND_H_
|
