net/
storage_thread.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::borrow::ToOwned;
6use std::collections::{BTreeMap, HashMap};
7use std::path::PathBuf;
8use std::thread;
9
10use base::generic_channel::{self, GenericReceiver, GenericSender};
11use base::id::WebViewId;
12use malloc_size_of::MallocSizeOf;
13use net_traits::storage_thread::{StorageThreadMsg, StorageType};
14use profile_traits::mem::{
15    ProcessReports, ProfilerChan as MemProfilerChan, Report, ReportKind, perform_memory_report,
16};
17use profile_traits::path;
18use rustc_hash::FxHashMap;
19use servo_url::ServoUrl;
20
21use crate::resource_thread;
22
23const QUOTA_SIZE_LIMIT: usize = 5 * 1024 * 1024;
24
25pub trait StorageThreadFactory {
26    fn new(config_dir: Option<PathBuf>, mem_profiler_chan: MemProfilerChan) -> Self;
27}
28
29impl StorageThreadFactory for GenericSender<StorageThreadMsg> {
30    /// Create a storage thread
31    fn new(
32        config_dir: Option<PathBuf>,
33        mem_profiler_chan: MemProfilerChan,
34    ) -> GenericSender<StorageThreadMsg> {
35        let (chan, port) = generic_channel::channel().unwrap();
36        let chan2 = chan.clone();
37        thread::Builder::new()
38            .name("StorageManager".to_owned())
39            .spawn(move || {
40                mem_profiler_chan.run_with_memory_reporting(
41                    || StorageManager::new(port, config_dir).start(),
42                    String::from("storage-reporter"),
43                    chan2,
44                    StorageThreadMsg::CollectMemoryReport,
45                );
46            })
47            .expect("Thread spawning failed");
48        chan
49    }
50}
51
52type OriginEntry = (usize, BTreeMap<String, String>);
53
54struct StorageManager {
55    port: GenericReceiver<StorageThreadMsg>,
56    session_data: FxHashMap<WebViewId, HashMap<String, OriginEntry>>,
57    local_data: HashMap<String, OriginEntry>,
58    config_dir: Option<PathBuf>,
59}
60
61impl StorageManager {
62    fn new(port: GenericReceiver<StorageThreadMsg>, config_dir: Option<PathBuf>) -> StorageManager {
63        let mut local_data = HashMap::new();
64        if let Some(ref config_dir) = config_dir {
65            resource_thread::read_json_from_file(&mut local_data, config_dir, "local_data.json");
66        }
67        StorageManager {
68            port,
69            session_data: FxHashMap::default(),
70            local_data,
71            config_dir,
72        }
73    }
74}
75
76impl StorageManager {
77    fn start(&mut self) {
78        loop {
79            match self.port.recv().unwrap() {
80                StorageThreadMsg::Length(sender, storage_type, webview_id, url) => {
81                    self.length(sender, storage_type, webview_id, url)
82                },
83                StorageThreadMsg::Key(sender, storage_type, webview_id, url, index) => {
84                    self.key(sender, storage_type, webview_id, url, index)
85                },
86                StorageThreadMsg::Keys(sender, storage_type, webview_id, url) => {
87                    self.keys(sender, storage_type, webview_id, url)
88                },
89                StorageThreadMsg::SetItem(sender, storage_type, webview_id, url, name, value) => {
90                    self.set_item(sender, storage_type, webview_id, url, name, value);
91                    self.save_state()
92                },
93                StorageThreadMsg::GetItem(sender, storage_type, webview_id, url, name) => {
94                    self.request_item(sender, storage_type, webview_id, url, name)
95                },
96                StorageThreadMsg::RemoveItem(sender, storage_type, webview_id, url, name) => {
97                    self.remove_item(sender, storage_type, webview_id, url, name);
98                    self.save_state()
99                },
100                StorageThreadMsg::Clear(sender, storage_type, webview_id, url) => {
101                    self.clear(sender, storage_type, webview_id, url);
102                    self.save_state()
103                },
104                StorageThreadMsg::Clone {
105                    sender,
106                    src: src_webview_id,
107                    dest: dest_webview_id,
108                } => {
109                    self.clone(src_webview_id, dest_webview_id);
110                    let _ = sender.send(());
111                },
112                StorageThreadMsg::CollectMemoryReport(sender) => {
113                    let reports = self.collect_memory_reports();
114                    sender.send(ProcessReports::new(reports));
115                },
116                StorageThreadMsg::Exit(sender) => {
117                    // Nothing to do since we save localstorage set eagerly.
118                    let _ = sender.send(());
119                    break;
120                },
121            }
122        }
123    }
124
125    fn collect_memory_reports(&self) -> Vec<Report> {
126        let mut reports = vec![];
127        perform_memory_report(|ops| {
128            reports.push(Report {
129                path: path!["storage", "local"],
130                kind: ReportKind::ExplicitJemallocHeapSize,
131                size: self.local_data.size_of(ops),
132            });
133
134            reports.push(Report {
135                path: path!["storage", "session"],
136                kind: ReportKind::ExplicitJemallocHeapSize,
137                size: self.session_data.size_of(ops),
138            });
139        });
140        reports
141    }
142
143    fn save_state(&self) {
144        if let Some(ref config_dir) = self.config_dir {
145            resource_thread::write_json_to_file(&self.local_data, config_dir, "local_data.json");
146        }
147    }
148
149    fn select_data(
150        &self,
151        storage_type: StorageType,
152        webview_id: WebViewId,
153        origin: &str,
154    ) -> Option<&OriginEntry> {
155        match storage_type {
156            StorageType::Session => self
157                .session_data
158                .get(&webview_id)
159                .and_then(|origin_map| origin_map.get(origin)),
160            StorageType::Local => self.local_data.get(origin),
161        }
162    }
163
164    fn select_data_mut(
165        &mut self,
166        storage_type: StorageType,
167        webview_id: WebViewId,
168        origin: &str,
169    ) -> Option<&mut OriginEntry> {
170        match storage_type {
171            StorageType::Session => self
172                .session_data
173                .get_mut(&webview_id)
174                .and_then(|origin_map| origin_map.get_mut(origin)),
175            StorageType::Local => self.local_data.get_mut(origin),
176        }
177    }
178
179    fn ensure_data_mut(
180        &mut self,
181        storage_type: StorageType,
182        webview_id: WebViewId,
183        origin: &str,
184    ) -> &mut OriginEntry {
185        match storage_type {
186            StorageType::Session => self
187                .session_data
188                .entry(webview_id)
189                .or_default()
190                .entry(origin.to_string())
191                .or_default(),
192            StorageType::Local => self.local_data.entry(origin.to_string()).or_default(),
193        }
194    }
195
196    fn length(
197        &self,
198        sender: GenericSender<usize>,
199        storage_type: StorageType,
200        webview_id: WebViewId,
201        url: ServoUrl,
202    ) {
203        let origin = self.origin_as_string(url);
204        let data = self.select_data(storage_type, webview_id, &origin);
205        sender
206            .send(data.map_or(0, |(_, entry)| entry.len()))
207            .unwrap();
208    }
209
210    fn key(
211        &self,
212        sender: GenericSender<Option<String>>,
213        storage_type: StorageType,
214        webview_id: WebViewId,
215        url: ServoUrl,
216        index: u32,
217    ) {
218        let origin = self.origin_as_string(url);
219        let data = self.select_data(storage_type, webview_id, &origin);
220        let key = data
221            .and_then(|(_, entry)| entry.keys().nth(index as usize))
222            .cloned();
223        sender.send(key).unwrap();
224    }
225
226    fn keys(
227        &self,
228        sender: GenericSender<Vec<String>>,
229        storage_type: StorageType,
230        webview_id: WebViewId,
231        url: ServoUrl,
232    ) {
233        let origin = self.origin_as_string(url);
234        let data = self.select_data(storage_type, webview_id, &origin);
235        let keys = data.map_or(vec![], |(_, entry)| entry.keys().cloned().collect());
236
237        sender.send(keys).unwrap();
238    }
239
240    /// Sends Ok(changed, Some(old_value)) in case there was a previous
241    /// value with the same key name but with different value name
242    /// otherwise sends Err(()) to indicate that the operation would result in
243    /// exceeding the quota limit
244    fn set_item(
245        &mut self,
246        sender: GenericSender<Result<(bool, Option<String>), ()>>,
247        storage_type: StorageType,
248        webview_id: WebViewId,
249        url: ServoUrl,
250        name: String,
251        value: String,
252    ) {
253        let origin = self.origin_as_string(url);
254
255        let (this_storage_size, other_storage_size) = {
256            let local_data = self.select_data(StorageType::Local, webview_id, &origin);
257            let session_data = self.select_data(StorageType::Session, webview_id, &origin);
258            let local_data_size = local_data.map_or(0, |&(total, _)| total);
259            let session_data_size = session_data.map_or(0, |&(total, _)| total);
260            match storage_type {
261                StorageType::Local => (local_data_size, session_data_size),
262                StorageType::Session => (session_data_size, local_data_size),
263            }
264        };
265
266        let &mut (ref mut total, ref mut entry) =
267            self.ensure_data_mut(storage_type, webview_id, &origin);
268
269        let mut new_total_size = this_storage_size + value.len();
270        if let Some(old_value) = entry.get(&name) {
271            new_total_size -= old_value.len();
272        } else {
273            new_total_size += name.len();
274        }
275
276        let message = if (new_total_size + other_storage_size) > QUOTA_SIZE_LIMIT {
277            Err(())
278        } else {
279            *total = new_total_size;
280            entry
281                .insert(name.clone(), value.clone())
282                .map_or(Ok((true, None)), |old| {
283                    if old == value {
284                        Ok((false, None))
285                    } else {
286                        Ok((true, Some(old)))
287                    }
288                })
289        };
290        sender.send(message).unwrap();
291    }
292
293    fn request_item(
294        &self,
295        sender: GenericSender<Option<String>>,
296        storage_type: StorageType,
297        webview_id: WebViewId,
298        url: ServoUrl,
299        name: String,
300    ) {
301        let origin = self.origin_as_string(url);
302        let data = self.select_data(storage_type, webview_id, &origin);
303        sender
304            .send(data.and_then(|(_, entry)| entry.get(&name)).cloned())
305            .unwrap();
306    }
307
308    /// Sends Some(old_value) in case there was a previous value with the key name, otherwise sends None
309    fn remove_item(
310        &mut self,
311        sender: GenericSender<Option<String>>,
312        storage_type: StorageType,
313        webview_id: WebViewId,
314        url: ServoUrl,
315        name: String,
316    ) {
317        let origin = self.origin_as_string(url);
318        let data = self.select_data_mut(storage_type, webview_id, &origin);
319        let old_value = data.and_then(|&mut (ref mut total, ref mut entry)| {
320            entry.remove(&name).inspect(|old| {
321                *total -= name.len() + old.len();
322            })
323        });
324        sender.send(old_value).unwrap();
325    }
326
327    fn clear(
328        &mut self,
329        sender: GenericSender<bool>,
330        storage_type: StorageType,
331        webview_id: WebViewId,
332        url: ServoUrl,
333    ) {
334        let origin = self.origin_as_string(url);
335        let data = self.select_data_mut(storage_type, webview_id, &origin);
336        sender
337            .send(data.is_some_and(|&mut (ref mut total, ref mut entry)| {
338                if !entry.is_empty() {
339                    entry.clear();
340                    *total = 0;
341                    true
342                } else {
343                    false
344                }
345            }))
346            .unwrap();
347    }
348
349    fn clone(&mut self, src_webview_id: WebViewId, dest_webview_id: WebViewId) {
350        let Some(src_origin_entries) = self.session_data.get(&src_webview_id) else {
351            return;
352        };
353
354        let dest_origin_entries = src_origin_entries.clone();
355        self.session_data
356            .insert(dest_webview_id, dest_origin_entries);
357    }
358
359    fn origin_as_string(&self, url: ServoUrl) -> String {
360        url.origin().ascii_serialization()
361    }
362}
net/storage_thread.rs

net/
storage_thread.rs
