script/dom/filesystem/filesystemdirectoryreader.rs
1/* This Source Code Form is subject to the terms of the Mozilla Public
2 * License, v. 2.0. If a copy of the MPL was not distributed with this
3 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
4
5use std::cell::Cell;
6
7use dom_struct::dom_struct;
8use js::context::JSContext;
9use script_bindings::cell::DomRefCell;
10use script_bindings::reflector::{Reflector, reflect_dom_object};
11
12use crate::dom::bindings::callback::{ExceptionHandling, RootedCallback, TracedCallback};
13use crate::dom::bindings::codegen::Bindings::FileSystemDirectoryReaderBinding::{
14 FileSystemDirectoryReaderMethods, FileSystemEntriesCallback,
15};
16use crate::dom::bindings::codegen::Bindings::FileSystemEntryBinding::ErrorCallback;
17use crate::dom::bindings::refcounted::Trusted;
18use crate::dom::bindings::reflector::DomGlobal;
19use crate::dom::bindings::root::{Dom, DomRoot, MutNullableDom};
20use crate::dom::domexception::{DOMErrorName, DOMException};
21use crate::dom::filesystemdirectoryentry::FileSystemDirectoryEntry;
22use crate::dom::globalscope::GlobalScope;
23
24/// Maximum number of entries returned by a single `readEntries()` call,
25/// matching Chromium's limit.
26const READ_ENTRIES_BATCH_SIZE: usize = 100;
27
28#[dom_struct]
29pub(crate) struct FileSystemDirectoryReader {
30 reflector_: Reflector,
31 dir: Dom<FileSystemDirectoryEntry>,
32 idx: Cell<usize>,
33 reading_flag: Cell<bool>,
34 done_flag: Cell<bool>,
35 reader_error: MutNullableDom<DOMException>,
36 pending_callbacks: DomRefCell<Vec<PendingEntriesCallback>>,
37 next_callback: Cell<usize>,
38}
39
40#[derive(JSTraceable, MallocSizeOf)]
41#[cfg_attr(crown, crown::unrooted_must_root_lint::must_root)]
42struct PendingEntriesCallback {
43 id: usize,
44 callback: TracedCallback<FileSystemEntriesCallback>,
45 error: Option<TracedCallback<ErrorCallback>>,
46}
47
48/// The action for a `readEntries` call decided synchronously.
49#[derive(Clone, Copy)]
50enum ReadEntriesAction {
51 /// Another read already in progress.
52 InvalidState,
53 /// A previous read failed.
54 ReaderError,
55 /// Every entry already produced.
56 Done,
57 /// Start a new read.
58 Read,
59}
60
61impl FileSystemDirectoryReader {
62 fn new_inherited(dir: &FileSystemDirectoryEntry) -> FileSystemDirectoryReader {
63 FileSystemDirectoryReader {
64 reflector_: Reflector::new(),
65 dir: Dom::from_ref(dir),
66 idx: Cell::new(0),
67 reading_flag: Cell::new(false),
68 done_flag: Cell::new(false),
69 reader_error: MutNullableDom::new(None),
70 pending_callbacks: Default::default(),
71 next_callback: Cell::new(0),
72 }
73 }
74
75 pub(crate) fn new(
76 cx: &mut JSContext,
77 global: &GlobalScope,
78 dir: &FileSystemDirectoryEntry,
79 ) -> DomRoot<FileSystemDirectoryReader> {
80 reflect_dom_object(
81 cx,
82 Box::new(FileSystemDirectoryReader::new_inherited(dir)),
83 global,
84 )
85 }
86}
87
88impl FileSystemDirectoryReaderMethods<crate::DomTypeHolder> for FileSystemDirectoryReader {
89 /// <https://wicg.github.io/entries-api/#dom-filesystemdirectoryreader-readentries>
90 fn ReadEntries(
91 &self,
92 success_callback: RootedCallback<FileSystemEntriesCallback>,
93 error_callback: Option<RootedCallback<ErrorCallback>>,
94 ) {
95 // Steps 1-4. The checks and the flag update run synchronously,
96 // before the callback task is queued.
97 //
98 // 1. If this’s reading flag is true, queue a task to invoke
99 // errorCallback with « a newly created "InvalidStateError"
100 // DOMException » and "report", and abort these steps.
101 // 2. If this’s reader error is not null, queue a task to invoke
102 // errorCallback (if given) with « reader error » and "report", and
103 // abort these steps.
104 // 3. If this’s done flag is true, queue a task to invoke
105 // successCallback with an empty list and "report", and abort these
106 // steps.
107 // 4. Set this’s reading flag to true.
108 let action = if self.reading_flag.get() {
109 ReadEntriesAction::InvalidState
110 } else if self.reader_error.get().is_some() {
111 ReadEntriesAction::ReaderError
112 } else if self.done_flag.get() {
113 ReadEntriesAction::Done
114 } else {
115 self.reading_flag.set(true);
116 ReadEntriesAction::Read
117 };
118
119 let id = self.next_callback.get();
120 self.pending_callbacks
121 .borrow_mut()
122 .push(PendingEntriesCallback {
123 id,
124 callback: success_callback.to_traced(),
125 error: error_callback.map(|callback| callback.to_traced()),
126 });
127 self.next_callback.set(id + 1);
128
129 let this = Trusted::new(self);
130 self.global()
131 .task_manager()
132 .dom_manipulation_task_source()
133 .queue(task!(invoke_read_entries: move |cx| {
134 let this = this.root();
135 let maybe_index = this
136 .pending_callbacks
137 .borrow()
138 .iter()
139 .position(|val| val.id == id);
140 if let Some(index) = maybe_index {
141 let error_callback = this
142 .pending_callbacks
143 .borrow_mut()
144 .get(index)
145 .and_then(|pending| pending.error.as_ref())
146 .map(|callback| callback.root(cx));
147 rooted!(&in(cx) let callback = this
148 .pending_callbacks
149 .borrow_mut()
150 .swap_remove(index)
151 .callback);
152 match action {
153 ReadEntriesAction::InvalidState => {
154 // 1. Invoke errorCallback with « a newly created
155 // "InvalidStateError" DOMException » and "report".
156 let error = DOMException::new(
157 cx,
158 &this.global(),
159 DOMErrorName::InvalidStateError,
160 );
161 if let Some(error_callback) = error_callback {
162 let _ = error_callback.Call__(
163 cx,
164 &error,
165 ExceptionHandling::Report,
166 );
167 }
168 }
169 ReadEntriesAction::ReaderError => {
170 // 2. Invoke errorCallback (if given) with « reader error » and "report".
171 let error = this
172 .reader_error
173 .get()
174 .expect("reader error must be set");
175 if let Some(error_callback) = error_callback {
176 let _ = error_callback.Call__(
177 cx,
178 &error,
179 ExceptionHandling::Report,
180 );
181 }
182 }
183 ReadEntriesAction::Done => {
184 // 3. Invoke successCallback with an empty list.
185 let _ = callback.Call__(cx, Vec::new(), ExceptionHandling::Report);
186 }
187 ReadEntriesAction::Read => {
188 // 5. In parallel, run these steps:
189 //
190 // 5.1. If this’s directory is null, then..
191 // TODO: (Not reachable until we hook embedder)
192 //
193 // 5.2. Let entries be a non-zero number of
194 // entries from this’s directory that have
195 // not yet been produced by this
196 // FileSystemDirectoryReader, if any.
197 let start = this.idx.get();
198 let entries = this.dir.children_batch(start, READ_ENTRIES_BATCH_SIZE);
199 this.idx.set(start + entries.len());
200 //
201 // 5.3. If the previous step failed (for example,
202 // the directory was deleted or permission is denied), then:
203 // (Not reachable as we use in-memory entries currently)
204 //
205 // 1. Queue a task to run these steps:
206 // 1. Let error be a an appropriate DOMException.
207 // 2. Set this’s reader error to error.
208 // 3. Set this’s reading flag to false.
209 // 4. Invoke errorCallback (if given) with
210 // « error » and "report".
211 // 2. Abort these steps.
212 // TODO: Reading the in-memory children cannot
213 // currently fail; this is where
214 // `reader_error` would be set.
215 //
216 // 5.4. Queue a task to run these steps:
217 // 5.4.1. If entries is empty, then set this’s done flag to true.
218 if entries.is_empty() {
219 this.done_flag.set(true);
220 }
221 // 5.4.2. Set this’s reading flag to false.
222 this.reading_flag.set(false);
223 // 5.4.3. Invoke successCallback with « entries » and "report".
224 let _ = callback.Call__(cx, entries, ExceptionHandling::Report);
225 }
226 }
227 }
228 }));
229 }
230}