api: Flatten and simplify Servo preferences (#34966)

Flatten and simplify Servo's preferences code. In addition, have both
preferences and options passed in as arguments to `Servo::new()` and
make sure not to use the globally set preferences in `servoshell` (as
much as possible now).

Instead of a complex procedural macro to generate preferences, just
expose a very simple derive macro that adds string based getters and
setters.

- All command-line parsing is moved to servoshell.
- There is no longer the concept of a missing preference.
- Preferences no longer have to be part of the resources bundle because
  they now have reasonable default values.
- servoshell specific preferences are no longer part of the preferences
  exposed by the Servo API.

Signed-off-by: Martin Robinson <mrobinson@igalia.com>
This commit is contained in:
Martin Robinson 2025-01-14 14:54:06 +01:00 committed by GitHub
parent c4c85affb5
commit 0e616e0c5d
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
316 changed files with 2088 additions and 3235 deletions

View file

@ -2,14 +2,12 @@
* 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/. */
use std::collections::HashMap;
use std::net::TcpStream;
use log::warn;
use serde::Serialize;
use serde_json::{Map, Value};
use servo_config::pref_util::PrefValue;
use servo_config::prefs::pref_map;
use servo_config::pref;
use crate::actor::{Actor, ActorMessageStatus, ActorRegistry};
use crate::protocol::JsonPacketStream;
@ -38,128 +36,93 @@ impl Actor for PreferenceActor {
stream: &mut TcpStream,
_id: StreamId,
) -> Result<ActorMessageStatus, ()> {
let Some(mut key) = msg.get("value").and_then(|v| v.as_str()) else {
let Some(key) = msg.get("value").and_then(|v| v.as_str()) else {
warn!("PreferenceActor: handle_message: value is not a string");
return Ok(ActorMessageStatus::Ignored);
};
// Mapping to translate a Firefox preference name onto the corresponding Servo preference name
let pref_name_mapping: HashMap<&str, &str> =
[("dom.serviceWorkers.enabled", "dom.serviceworker.enabled")]
.iter()
.copied()
.collect();
if pref_name_mapping.contains_key(key) {
key = pref_name_mapping.get(key).unwrap();
// TODO: Map more preferences onto their Servo values.
Ok(match key {
"dom.serviceWorkers.enabled" => {
self.write_bool(pref!(dom_serviceworker_enabled), stream)
},
_ => self.handle_missing_preference(msg_type, stream),
})
}
}
impl PreferenceActor {
fn handle_missing_preference(
&self,
msg_type: &str,
stream: &mut TcpStream,
) -> ActorMessageStatus {
match msg_type {
"getBoolPref" => self.write_bool(false, stream),
"getCharPref" => self.write_char("".into(), stream),
"getIntPref" => self.write_int(0, stream),
"getFloatPref" => self.write_float(0., stream),
_ => ActorMessageStatus::Ignored,
}
}
fn write_bool(&self, pref_value: bool, stream: &mut TcpStream) -> ActorMessageStatus {
#[derive(Serialize)]
struct BoolReply {
from: String,
value: bool,
}
let pref_value = pref_map().get(key);
Ok(handle_preference_value(
pref_value,
self.name(),
msg_type,
stream,
))
let reply = BoolReply {
from: self.name.clone(),
value: pref_value,
};
let _ = stream.write_json_packet(&reply);
ActorMessageStatus::Processed
}
fn write_char(&self, pref_value: String, stream: &mut TcpStream) -> ActorMessageStatus {
#[derive(Serialize)]
struct CharReply {
from: String,
value: String,
}
let reply = CharReply {
from: self.name.clone(),
value: pref_value,
};
let _ = stream.write_json_packet(&reply);
ActorMessageStatus::Processed
}
fn write_int(&self, pref_value: i64, stream: &mut TcpStream) -> ActorMessageStatus {
#[derive(Serialize)]
struct IntReply {
from: String,
value: i64,
}
let reply = IntReply {
from: self.name.clone(),
value: pref_value,
};
let _ = stream.write_json_packet(&reply);
ActorMessageStatus::Processed
}
fn write_float(&self, pref_value: f64, stream: &mut TcpStream) -> ActorMessageStatus {
#[derive(Serialize)]
struct FloatReply {
from: String,
value: f64,
}
let reply = FloatReply {
from: self.name.clone(),
value: pref_value,
};
let _ = stream.write_json_packet(&reply);
ActorMessageStatus::Processed
}
}
fn handle_preference_value(
pref_value: PrefValue,
name: String,
msg_type: &str,
stream: &mut TcpStream,
) -> ActorMessageStatus {
match pref_value {
PrefValue::Float(value) => {
let reply = FloatReply { from: name, value };
let _ = stream.write_json_packet(&reply);
ActorMessageStatus::Processed
},
PrefValue::Int(value) => {
let reply = IntReply { from: name, value };
let _ = stream.write_json_packet(&reply);
ActorMessageStatus::Processed
},
PrefValue::Str(value) => {
let reply = CharReply { from: name, value };
let _ = stream.write_json_packet(&reply);
ActorMessageStatus::Processed
},
PrefValue::Bool(value) => {
let reply = BoolReply { from: name, value };
let _ = stream.write_json_packet(&reply);
ActorMessageStatus::Processed
},
PrefValue::Array(values) => {
let mut result = ActorMessageStatus::Processed;
for value in values {
result = handle_preference_value(value, name.clone(), msg_type, stream);
}
result
},
PrefValue::Missing => handle_missing_preference(name, msg_type, stream),
}
}
// if the preferences are missing from pref_map then we return a
// fake preference response based on msg_type.
fn handle_missing_preference(
name: String,
msg_type: &str,
stream: &mut TcpStream,
) -> ActorMessageStatus {
match msg_type {
"getBoolPref" => {
let reply = BoolReply {
from: name,
value: false,
};
let _ = stream.write_json_packet(&reply);
ActorMessageStatus::Processed
},
"getCharPref" => {
let reply = CharReply {
from: name,
value: "".to_owned(),
};
let _ = stream.write_json_packet(&reply);
ActorMessageStatus::Processed
},
"getIntPref" => {
let reply = IntReply {
from: name,
value: 0,
};
let _ = stream.write_json_packet(&reply);
ActorMessageStatus::Processed
},
_ => ActorMessageStatus::Ignored,
}
}
#[derive(Serialize)]
struct BoolReply {
from: String,
value: bool,
}
#[derive(Serialize)]
struct CharReply {
from: String,
value: String,
}
#[derive(Serialize)]
struct IntReply {
from: String,
value: i64,
}
#[derive(Serialize)]
struct FloatReply {
from: String,
value: f64,
}