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>

components/net/async_runtime.rs

@@ -19,9 +19,9 @@ pub static HANDLE: LazyLock<Mutex<Option<Runtime>>> = LazyLock::new(|| {
             .worker_threads(
                 thread::available_parallelism()
                     .map(|i| i.get())
-                    .unwrap_or(servo_config::pref!(threadpools.fallback_worker_num) as usize)
+                    .unwrap_or(servo_config::pref!(threadpools_fallback_worker_num) as usize)
                     .min(
-                        servo_config::pref!(threadpools.async_runtime_workers.max).max(1) as usize,
+                        servo_config::pref!(threadpools_async_runtime_workers_max).max(1) as usize,
                     ),
             )
             .enable_io()

components/net/decoder.rs

@@ -280,7 +280,7 @@ impl Stream for BodyStream {
                     .content_length
                     .map_or(false, |c| c.0 == self.total_read);
                 if self.is_secure_scheme &&
-                    (all_content_read || pref!(network.tls.ignore_unexpected_eof))
+                    (all_content_read || pref!(network_tls_ignore_unexpected_eof))
                 {
                     let source = err.source();
                     let is_unexpected_eof = source

components/net/filemanager_thread.rs

@@ -602,7 +602,7 @@ impl FileManagerStore {
         // Check if the select_files preference is enabled
         // to ensure process-level security against compromised script;
         // Then try applying opt_test_path directly for testing convenience
-        let opt_s = if pref!(dom.testing.html_input_element.select_files.enabled) {
+        let opt_s = if pref!(dom_testing_html_input_element_select_files_enabled) {
             opt_test_path
         } else {
             self.query_files_from_embedder(patterns, false, embedder_proxy)
@@ -632,7 +632,7 @@ impl FileManagerStore {
         // Check if the select_files preference is enabled
         // to ensure process-level security against compromised script;
         // Then try applying opt_test_paths directly for testing convenience
-        let opt_v = if pref!(dom.testing.html_input_element.select_files.enabled) {
+        let opt_v = if pref!(dom_testing_html_input_element_select_files_enabled) {
             opt_test_paths
         } else {
             self.query_files_from_embedder(patterns, true, embedder_proxy)

components/net/hsts.rs

@@ -144,8 +144,8 @@ impl HstsList {
             return;
         }
 
-        let upgrade_scheme = if pref!(network.enforce_tls.enabled) {
-            if (!pref!(network.enforce_tls.localhost) &&
+        let upgrade_scheme = if pref!(network_enforce_tls_enabled) {
+            if (!pref!(network_enforce_tls_localhost) &&
                 match url.host() {
                     Some(Host::Domain(domain)) => {
                         domain.ends_with(".localhost") || domain == "localhost"
@@ -154,7 +154,7 @@ impl HstsList {
                     Some(Host::Ipv6(ipv6)) => ipv6.is_loopback(),
                     _ => false,
                 }) ||
-                (!pref!(network.enforce_tls.onion) &&
+                (!pref!(network_enforce_tls_onion) &&
                     url.domain()
                         .is_some_and(|domain| domain.ends_with(".onion")))
             {

components/net/http_cache.rs

@@ -756,7 +756,7 @@ impl HttpCache {
     /// Storing Responses in Caches.
     /// <https://tools.ietf.org/html/rfc7234#section-3>
     pub fn store(&mut self, request: &Request, response: &Response) {
-        if pref!(network.http_cache.disabled) {
+        if pref!(network_http_cache_disabled) {
             return;
         }
         if request.method != Method::GET {

components/net/image_cache.rs

@@ -17,6 +17,7 @@ use net_traits::image_cache::{
 use net_traits::request::CorsSettings;
 use net_traits::{FetchMetadata, FetchResponseMsg, FilteredMetadata, NetworkError};
 use pixels::{load_from_memory, CorsStatus, Image, ImageMetadata, PixelFormat};
+use servo_config::pref;
 use servo_url::{ImmutableOrigin, ServoUrl};
 use webrender_api::units::DeviceIntSize;
 use webrender_api::{ImageDescriptor, ImageDescriptorFlags, ImageFormat};
@@ -422,8 +423,8 @@ impl ImageCache for ImageCacheImpl {
         // If no information can be obtained about the system, uses 4 threads as a default
         let thread_count = thread::available_parallelism()
             .map(|i| i.get())
-            .unwrap_or(servo_config::pref!(threadpools.fallback_worker_num) as usize)
-            .min(servo_config::pref!(threadpools.async_runtime_workers.max).max(1) as usize);
+            .unwrap_or(pref!(threadpools_fallback_worker_num) as usize)
+            .min(pref!(threadpools_async_runtime_workers_max).max(1) as usize);
 
         ImageCacheImpl {
             store: Arc::new(Mutex::new(ImageCacheStore {

components/net/local_directory_listing.rs

@@ -16,7 +16,7 @@ use servo_url::ServoUrl;
 use url::Url;
 
 pub fn fetch(request: &mut Request, url: ServoUrl, path_buf: PathBuf) -> Response {
-    if !pref!(network.local_directory_listing.enabled) {
+    if !pref!(network_local_directory_listing_enabled) {
         // If you want to be able to browse local directories, configure Servo prefs so that
         // "network.local_directory_listing.enabled" is set to true.
         return Response::network_error(NetworkError::Internal(

components/net/resource_thread.rs

@@ -695,8 +695,8 @@ impl CoreResourceManager {
     ) -> CoreResourceManager {
         let num_threads = thread::available_parallelism()
             .map(|i| i.get())
-            .unwrap_or(servo_config::pref!(threadpools.fallback_worker_num) as usize)
-            .min(servo_config::pref!(threadpools.resource_workers.max).max(1) as usize);
+            .unwrap_or(servo_config::pref!(threadpools_fallback_worker_num) as usize)
+            .min(servo_config::pref!(threadpools_resource_workers_max).max(1) as usize);
         let pool = CoreResourceThreadPool::new(num_threads, "CoreResourceThreadPool".to_string());
         let pool_handle = Arc::new(pool);
         CoreResourceManager {

components/net/tests/filemanager_thread.rs

@@ -15,16 +15,19 @@ use net_traits::blob_url_store::BlobURLStoreError;
 use net_traits::filemanager_thread::{
     FileManagerThreadError, FileManagerThreadMsg, ReadFileProgress,
 };
-use servo_config::set_pref;
+use servo_config::prefs::Preferences;
 
 use crate::create_embedder_proxy;
 
 #[test]
 fn test_filemanager() {
+    let mut preferences = Preferences::default();
+    preferences.dom_testing_html_input_element_select_files_enabled = true;
+    servo_config::prefs::set(preferences);
+
     let pool = CoreResourceThreadPool::new(1, "CoreResourceTestPool".to_string());
     let pool_handle = Arc::new(pool);
     let filemanager = FileManager::new(create_embedder_proxy(), Arc::downgrade(&pool_handle));
-    set_pref!(dom.testing.html_input_element.select_files.enabled, true);
 
     // Try to open a dummy file "components/net/tests/test.jpeg" in tree
     let mut handler = File::open("tests/test.jpeg").expect("test.jpeg is stolen");