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
|
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
//! Supports dynamic assertions in debug builds about what sort of thread is
//! running and what state it's in.
//!
//! In release builds, `get` returns 0. All of the other functions inline
//! away to nothing.
pub use self::imp::{enter, exit, get, initialize};
bitflags! {
pub flags ThreadState: u32 {
const SCRIPT = 0x01,
const LAYOUT = 0x02,
const PAINT = 0x04,
const IN_WORKER = 0x0100,
const IN_GC = 0x0200,
const IN_HTML_PARSER = 0x0400,
}
}
macro_rules! thread_types ( ( $( $fun:ident = $flag:ident ; )* ) => (
impl ThreadState {
$(
#[cfg(debug_assertions)]
pub fn $fun(self) -> bool {
self.contains($flag)
}
#[cfg(not(debug_assertions))]
pub fn $fun(self) -> bool {
true
}
)*
}
#[cfg(debug_assertions)]
static TYPES: &'static [ThreadState]
= &[ $( $flag ),* ];
));
thread_types! {
is_script = SCRIPT;
is_layout = LAYOUT;
is_paint = PAINT;
}
#[cfg(debug_assertions)]
mod imp {
use std::cell::RefCell;
use super::{TYPES, ThreadState};
thread_local!(static STATE: RefCell<Option<ThreadState>> = RefCell::new(None));
pub fn initialize(x: ThreadState) {
STATE.with(|ref k| {
match *k.borrow() {
Some(s) => panic!("Thread state already initialized as {:?}", s),
None => ()
};
*k.borrow_mut() = Some(x);
});
get(); // check the assertion below
}
pub fn get() -> ThreadState {
let state = STATE.with(|ref k| {
match *k.borrow() {
None => panic!("Thread state not initialized"),
Some(s) => s,
}
});
// Exactly one of the thread type flags should be set.
assert_eq!(1, TYPES.iter().filter(|&&ty| state.contains(ty)).count());
state
}
pub fn enter(x: ThreadState) {
let state = get();
assert!(!state.intersects(x));
STATE.with(|ref k| {
*k.borrow_mut() = Some(state | x);
})
}
pub fn exit(x: ThreadState) {
let state = get();
assert!(state.contains(x));
STATE.with(|ref k| {
*k.borrow_mut() = Some(state & !x);
})
}
}
#[cfg(not(debug_assertions))]
mod imp {
use super::ThreadState;
#[inline(always)] pub fn initialize(_: ThreadState) { }
#[inline(always)] pub fn get() -> ThreadState { ThreadState::empty() }
#[inline(always)] pub fn enter(_: ThreadState) { }
#[inline(always)] pub fn exit(_: ThreadState) { }
}
|
