Skip to main content

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}