servo-devtools 0.1.0

A component of the servo web-engine.
Documentation 
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

/* 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 https://mozilla.org/MPL/2.0/. */

//! Liberally derived from the [Firefox JS implementation](http://mxr.mozilla.org/mozilla-central/source/toolkit/devtools/server/actors/inspector.js).

use atomic_refcell::AtomicRefCell;
use malloc_size_of_derive::MallocSizeOf;
use serde::Serialize;
use serde_json::{self, Map, Value};

use crate::actor::{Actor, ActorError, ActorRegistry};
use crate::actors::inspector::highlighter::HighlighterActor;
use crate::actors::inspector::page_style::{PageStyleActor, PageStyleMsg};
use crate::actors::inspector::walker::{WalkerActor, WalkerMsg};
use crate::protocol::ClientRequest;
use crate::{ActorMsg, StreamId};

pub mod accessibility;
pub mod css_properties;
pub mod highlighter;
pub mod layout;
pub mod node;
pub mod page_style;
pub mod style_rule;
pub mod walker;

#[derive(Serialize)]
struct GetHighlighterReply {
    from: String,
    highlighter: ActorMsg,
}

#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct GetPageStyleReply {
    from: String,
    page_style: PageStyleMsg,
}

#[derive(Serialize)]
struct GetWalkerReply {
    from: String,
    walker: WalkerMsg,
}

#[derive(Serialize)]
struct SupportsHighlightersReply {
    from: String,
    value: bool,
}

#[derive(MallocSizeOf)]
pub(crate) struct InspectorActor {
    name: String,
    highlighter_name: String,
    page_style_name: String,
    pub(crate) walker: String,
}

impl Actor for InspectorActor {
    fn name(&self) -> String {
        self.name.clone()
    }

    fn handle_message(
        &self,
        request: ClientRequest,
        registry: &ActorRegistry,
        msg_type: &str,
        _msg: &Map<String, Value>,
        _id: StreamId,
    ) -> Result<(), ActorError> {
        match msg_type {
            "getPageStyle" => {
                let msg = GetPageStyleReply {
                    from: self.name(),
                    page_style: registry.encode::<PageStyleActor, _>(&self.page_style_name),
                };
                request.reply_final(&msg)?
            },

            "getHighlighterByType" => {
                let msg = GetHighlighterReply {
                    from: self.name(),
                    highlighter: registry.encode::<HighlighterActor, _>(&self.highlighter_name),
                };
                request.reply_final(&msg)?
            },

            "getWalker" => {
                let msg = GetWalkerReply {
                    from: self.name(),
                    walker: registry.encode::<WalkerActor, _>(&self.walker),
                };
                request.reply_final(&msg)?
            },

            "supportsHighlighters" => {
                let msg = SupportsHighlightersReply {
                    from: self.name(),
                    value: true,
                };
                request.reply_final(&msg)?
            },

            _ => return Err(ActorError::UnrecognizedPacketType),
        };
        Ok(())
    }
}

impl InspectorActor {
    pub fn register(registry: &ActorRegistry, browsing_context_name: String) -> String {
        let highlighter_actor = HighlighterActor {
            name: registry.new_name::<HighlighterActor>(),
            browsing_context_name: browsing_context_name.clone(),
        };

        let page_style_actor = PageStyleActor {
            name: registry.new_name::<PageStyleActor>(),
        };

        let walker = WalkerActor {
            name: registry.new_name::<WalkerActor>(),
            mutations: AtomicRefCell::new(vec![]),
            browsing_context_name,
        };

        let inspector_actor = Self {
            name: registry.new_name::<InspectorActor>(),
            highlighter_name: highlighter_actor.name(),
            page_style_name: page_style_actor.name(),
            walker: walker.name(),
        };
        let inspector_name = inspector_actor.name();

        registry.register(highlighter_actor);
        registry.register(page_style_actor);
        registry.register(walker);
        registry.register(inspector_actor);

        inspector_name
    }
}