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
|
// Copyright 2018 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef THIRD_PARTY_BLINK_RENDERER_MODULES_FILESYSTEM_FILE_SYSTEM_DISPATCHER_H_
#define THIRD_PARTY_BLINK_RENDERER_MODULES_FILESYSTEM_FILE_SYSTEM_DISPATCHER_H_
#include <memory>
#include "mojo/public/cpp/bindings/pending_remote.h"
#include "third_party/blink/public/mojom/filesystem/file_system.mojom-blink.h"
#include "third_party/blink/renderer/modules/filesystem/file_system_callbacks.h"
#include "third_party/blink/renderer/platform/heap/collection_support/heap_hash_map.h"
#include "third_party/blink/renderer/platform/heap/disallow_new_wrapper.h"
#include "third_party/blink/renderer/platform/heap/garbage_collected.h"
#include "third_party/blink/renderer/platform/mojo/heap_mojo_remote.h"
#include "third_party/blink/renderer/platform/mojo/heap_mojo_unique_receiver_set.h"
#include "third_party/blink/renderer/platform/supplementable.h"
namespace WTF {
class String;
}
namespace blink {
class Blob;
class ExecutionContext;
class KURL;
class SecurityOrigin;
// Sends messages via mojo to the blink::mojom::FileSystemManager service
// running in the browser process. It is owned by ExecutionContext, and
// instances are created lazily by calling FileSystemDispatcher::From().
class FileSystemDispatcher : public GarbageCollected<FileSystemDispatcher>,
public Supplement<ExecutionContext> {
public:
using StatusCallback = base::OnceCallback<void(base::File::Error error)>;
using WriteCallback =
base::RepeatingCallback<void(int64_t bytes, bool complete)>;
static const char kSupplementName[];
static FileSystemDispatcher& From(ExecutionContext* context);
explicit FileSystemDispatcher(ExecutionContext& context);
virtual ~FileSystemDispatcher();
mojom::blink::FileSystemManager& GetFileSystemManager();
void OpenFileSystem(const SecurityOrigin* origin,
mojom::blink::FileSystemType type,
std::unique_ptr<FileSystemCallbacks> callbacks);
void OpenFileSystemSync(const SecurityOrigin* origin,
mojom::blink::FileSystemType type,
std::unique_ptr<FileSystemCallbacks> callbacks);
void ResolveURL(const KURL& filesystem_url,
std::unique_ptr<ResolveURICallbacks> callbacks);
void ResolveURLSync(const KURL& filesystem_url,
std::unique_ptr<ResolveURICallbacks> callbacks);
void Move(const KURL& src_path,
const KURL& dest_path,
std::unique_ptr<EntryCallbacks> callbacks);
void MoveSync(const KURL& src_path,
const KURL& dest_path,
std::unique_ptr<EntryCallbacks> callbacks);
void Copy(const KURL& src_path,
const KURL& dest_path,
std::unique_ptr<EntryCallbacks> callbacks);
void CopySync(const KURL& src_path,
const KURL& dest_path,
std::unique_ptr<EntryCallbacks> callbacks);
void Remove(const KURL& path,
bool recursive,
std::unique_ptr<VoidCallbacks> callbacks);
void RemoveSync(const KURL& path,
bool recursive,
std::unique_ptr<VoidCallbacks> callbacks);
void ReadMetadata(const KURL& path,
std::unique_ptr<MetadataCallbacks> callbacks);
void ReadMetadataSync(const KURL& path,
std::unique_ptr<MetadataCallbacks> callbacks);
void CreateFile(const KURL& path,
bool exclusive,
std::unique_ptr<EntryCallbacks> callbacks);
void CreateFileSync(const KURL& path,
bool exclusive,
std::unique_ptr<EntryCallbacks> callbacks);
void CreateDirectory(const KURL& path,
bool exclusive,
bool recursive,
std::unique_ptr<EntryCallbacks> callbacks);
void CreateDirectorySync(const KURL& path,
bool exclusive,
bool recursive,
std::unique_ptr<EntryCallbacks> callbacks);
void Exists(const KURL& path,
bool for_directory,
std::unique_ptr<EntryCallbacks> callbacks);
void ExistsSync(const KURL& path,
bool for_directory,
std::unique_ptr<EntryCallbacks> callbacks);
void ReadDirectory(const KURL& path,
std::unique_ptr<EntriesCallbacks> callbacks);
void ReadDirectorySync(const KURL& path,
std::unique_ptr<EntriesCallbacks> callbacks);
void InitializeFileWriter(const KURL& path,
std::unique_ptr<FileWriterCallbacks>);
void InitializeFileWriterSync(const KURL& path,
std::unique_ptr<FileWriterCallbacks>);
void Truncate(const KURL& path,
int64_t offset,
int* request_id_out,
StatusCallback callback);
void TruncateSync(const KURL& path, int64_t offset, StatusCallback callback);
void Write(const KURL& path,
const Blob& blob,
int64_t offset,
int* request_id_out,
const WriteCallback& success_callback,
StatusCallback error_callback);
void WriteSync(const KURL& path,
const Blob& blob,
int64_t offset,
const WriteCallback& success_callback,
StatusCallback error_callback);
void Cancel(int request_id_to_cancel, StatusCallback callback);
void CreateSnapshotFile(const KURL& file_path,
std::unique_ptr<SnapshotFileCallbackBase> callbacks);
void CreateSnapshotFileSync(
const KURL& file_path,
std::unique_ptr<SnapshotFileCallbackBase> callbacks);
void Trace(Visitor*) const override;
private:
class WriteListener;
class ReadDirectoryListener;
void DidOpenFileSystem(std::unique_ptr<FileSystemCallbacks> callbacks,
const String& name,
const KURL& root,
base::File::Error error_code);
void DidResolveURL(std::unique_ptr<ResolveURICallbacks> callbacks,
mojom::blink::FileSystemInfoPtr info,
const base::FilePath& file_path,
bool is_directory,
base::File::Error error_code);
void DidRemove(std::unique_ptr<VoidCallbacks> callbacks,
base::File::Error error_code);
void DidFinish(std::unique_ptr<EntryCallbacks> callbacks,
base::File::Error error_code);
void DidReadMetadata(std::unique_ptr<MetadataCallbacks> callbacks,
const base::File::Info& file_info,
base::File::Error error);
void DidReadDirectory(
std::unique_ptr<EntriesCallbacks> callbacks,
Vector<filesystem::mojom::blink::DirectoryEntryPtr> entries,
base::File::Error error_code);
void InitializeFileWriterCallback(
const KURL& path,
std::unique_ptr<FileWriterCallbacks> callbacks,
const base::File::Info& file_info,
base::File::Error error);
void DidTruncate(int operation_id,
StatusCallback callback,
base::File::Error error_code);
void DidWrite(const WriteCallback& callback,
int operation_id,
int64_t bytes,
bool complete);
void WriteErrorCallback(StatusCallback callback,
int operation_id,
base::File::Error error);
void DidCancel(StatusCallback callback,
int cancelled_operation_id,
base::File::Error error_code);
void DidCreateSnapshotFile(
std::unique_ptr<SnapshotFileCallbackBase> callbacks,
const base::File::Info& file_info,
const base::FilePath& platform_path,
base::File::Error error_code,
mojo::PendingRemote<mojom::blink::ReceivedSnapshotListener> listener);
void RemoveOperationRemote(int operation_id);
HeapMojoRemote<mojom::blink::FileSystemManager> file_system_manager_;
using OperationsMap =
HeapHashMap<int,
Member<DisallowNewWrapper<HeapMojoRemote<
mojom::blink::FileSystemCancellableOperation>>>>;
OperationsMap cancellable_operations_;
int next_operation_id_;
HeapMojoUniqueReceiverSet<mojom::blink::FileSystemOperationListener>
op_listeners_;
};
} // namespace blink
#endif // THIRD_PARTY_BLINK_RENDERER_MODULES_FILESYSTEM_FILE_SYSTEM_DISPATCHER_H_
|
