servoshell/

prefs.rs

/* 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/. */

use core::panic;
use std::cell::Cell;
use std::collections::HashMap;
use std::fs::{self, read_to_string};
use std::path::{Path, PathBuf};
use std::rc::Rc;
use std::str::FromStr;
#[cfg(any(target_os = "android", target_env = "ohos"))]
use std::sync::OnceLock;
use std::{env, fmt};

use bpaf::*;
use euclid::Size2D;
use log::warn;
use serde_json::Value;
use servo::user_contents::UserStyleSheet;
use servo::{
    DeviceIndependentPixel, DiagnosticsLogging, DiagnosticsLoggingOption, Opts, OutputOptions,
    PrefValue, Preferences,
};
use url::Url;

use crate::VERSION;

/// Preferences enabled when servoshell is launched with the `--enable-experimental-web-platform-features` flag.
///
/// These preferences are disabled by default but activated in experimental mode.
/// For more details, see the
/// [experimental features documentation](https://book.servo.org/design-documentation/experimental-features.html).
pub(crate) static EXPERIMENTAL_PREFS: &[&str] = &[
    "dom_async_clipboard_enabled",
    "dom_exec_command_enabled",
    "dom_fontface_enabled",
    "dom_indexeddb_enabled",
    "dom_intersection_observer_enabled",
    "dom_navigator_protocol_handlers_enabled",
    "dom_notification_enabled",
    "dom_offscreen_canvas_enabled",
    "dom_permissions_enabled",
    "dom_sanitizer_enabled",
    "dom_storage_manager_api_enabled",
    "dom_webgl2_enabled",
    "dom_webgpu_enabled",
    "layout_css_ellipse_corners_enabled",
    "layout_css_progress_function_enabled",
    "layout_columns_enabled",
    "layout_container_queries_enabled",
    "layout_variable_fonts_enabled",
];

#[cfg_attr(any(target_os = "android", target_env = "ohos"), expect(dead_code))]
#[derive(Clone)]
pub(crate) struct ServoShellPreferences {
    /// A URL to load when starting servoshell.
    pub url: Option<String>,
    /// An override value for the device pixel ratio.
    pub device_pixel_ratio_override: Option<f32>,
    /// Whether or not to attempt clean shutdown.
    pub clean_shutdown: bool,
    /// Enable native window's titlebar and decorations.
    pub no_native_titlebar: bool,
    /// URL string of the homepage.
    pub homepage: String,
    /// URL string of the search engine page with '%s' standing in for the search term.
    /// For example <https://duckduckgo.com/html/?q=%s>.
    pub searchpage: String,
    /// Whether or not to run servoshell in headless mode. While running in headless
    /// mode, image output is supported.
    pub headless: bool,
    /// Filter directives for our tracing implementation.
    ///
    /// Overrides directives specified via `SERVO_TRACING` if set.
    /// See: <https://docs.rs/tracing-subscriber/0.3.19/tracing_subscriber/filter/struct.EnvFilter.html#directives>
    pub tracing_filter: Option<String>,
    /// The initial requested inner size of the window.
    pub initial_window_size: Size2D<u32, DeviceIndependentPixel>,
    /// An override for the screen resolution. This is useful for testing behavior on different screen sizes,
    /// such as the screen of a mobile device.
    pub screen_size_override: Option<Size2D<u32, DeviceIndependentPixel>>,
    /// Whether or not to simulate touch events using mouse events.
    pub simulate_touch_events: bool,
    /// If not-None, the path to a file to output the default WebView's rendered output
    /// after waiting for a stable image, this implies `Self::exit_after_load`.
    pub output_image_path: Option<String>,
    /// Whether or not to exit after Servo detects a stable output image in all WebViews.
    pub exit_after_stable_image: bool,
    /// Where to load userscripts from, if any.
    /// and if the option isn't passed userscripts won't be loaded.
    pub userscripts_directory: Option<PathBuf>,
    /// A set of [`UserStylesheets`] to load for content.
    pub user_stylesheets: Vec<Rc<UserStyleSheet>>,
    /// `None` to disable WebDriver or `Some` with a port number to start a server to listen to
    /// remote WebDriver commands.
    pub webdriver_port: Cell<Option<u16>>,
    /// Whether the CLI option to enable experimental prefs was present at startup.
    pub experimental_preferences_enabled: bool,
    /// Log filter given in the `log_filter` spec as a String, if any.
    /// If a filter is passed, the logger should adjust accordingly.
    #[cfg(target_env = "ohos")]
    pub log_filter: Option<String>,
    /// Log also to a file
    #[cfg(target_env = "ohos")]
    pub log_to_file: bool,
}

impl Default for ServoShellPreferences {
    fn default() -> Self {
        Self {
            clean_shutdown: false,
            device_pixel_ratio_override: None,
            headless: false,
            homepage: "https://servo.org".into(),
            initial_window_size: Size2D::new(1024, 740),
            no_native_titlebar: true,
            screen_size_override: None,
            simulate_touch_events: false,
            searchpage: "https://duckduckgo.com/html/?q=%s".into(),
            tracing_filter: None,
            url: None,
            output_image_path: None,
            exit_after_stable_image: false,
            userscripts_directory: None,
            user_stylesheets: Default::default(),
            webdriver_port: Cell::new(None),
            #[cfg(target_env = "ohos")]
            log_filter: None,
            #[cfg(target_env = "ohos")]
            log_to_file: false,
            experimental_preferences_enabled: false,
        }
    }
}

#[cfg(all(
    unix,
    not(target_os = "macos"),
    not(target_os = "ios"),
    not(target_os = "android"),
    not(target_env = "ohos")
))]
pub fn default_config_dir() -> Option<PathBuf> {
    let mut config_dir = ::dirs::config_dir().unwrap();
    config_dir.push("servo");
    config_dir.push("default");
    Some(config_dir)
}

/// Overrides the default preference dir
#[cfg(any(target_os = "android", target_env = "ohos"))]
pub(crate) static DEFAULT_CONFIG_DIR: OnceLock<PathBuf> = OnceLock::new();
#[cfg(any(target_os = "android", target_env = "ohos"))]
pub fn default_config_dir() -> Option<PathBuf> {
    DEFAULT_CONFIG_DIR.get().cloned()
}

#[cfg(target_os = "macos")]
pub fn default_config_dir() -> Option<PathBuf> {
    // FIXME: use `config_dir()` ($HOME/Library/Preferences)
    // instead of `data_dir()` ($HOME/Library/Application Support) ?
    let mut config_dir = ::dirs::data_dir().unwrap();
    config_dir.push("Servo");
    Some(config_dir)
}

#[cfg(target_os = "windows")]
pub fn default_config_dir() -> Option<PathBuf> {
    let mut config_dir = ::dirs::config_dir().unwrap();
    config_dir.push("Servo");
    Some(config_dir)
}

/// Get a Servo [`Preferences`] to use when initializing Servo by first reading the user
/// preferences file and then overriding these preferences with the ones from the `--prefs-file`
/// command-line argument, if given.
fn get_preferences(prefs_files: &[PathBuf], config_dir: &Option<PathBuf>) -> Preferences {
    // Do not read any preferences files from the disk when testing as we do not want it
    // to throw off test results.
    if cfg!(test) {
        return Preferences::default();
    }

    let user_prefs_path = config_dir
        .clone()
        .map(|path| path.join("prefs.json"))
        .filter(|path| path.exists());
    let user_prefs_hash = user_prefs_path.map(read_prefs_file).unwrap_or_default();

    let apply_preferences =
        |preferences: &mut Preferences, preferences_hash: HashMap<String, PrefValue>| {
            for (key, value) in preferences_hash.iter() {
                preferences.set_value(key, value.clone());
            }
        };

    let mut preferences = Preferences::default();
    apply_preferences(&mut preferences, user_prefs_hash);
    for pref_file_path in prefs_files.iter() {
        apply_preferences(&mut preferences, read_prefs_file(pref_file_path))
    }

    preferences
}

fn read_prefs_file<P: AsRef<Path>>(path: P) -> HashMap<String, PrefValue> {
    read_prefs_map(&read_to_string(path).expect("Error opening user prefs"))
}

pub fn read_prefs_map(txt: &str) -> HashMap<String, PrefValue> {
    let prefs: HashMap<String, Value> = serde_json::from_str(txt)
        .map_err(|_| panic!("Could not parse preferences JSON"))
        .unwrap();
    prefs
        .into_iter()
        .map(|(key, value)| {
            let value = (&value)
                .try_into()
                .map_err(|error| panic!("{error}"))
                .unwrap();
            (key, value)
        })
        .collect()
}

#[expect(clippy::large_enum_variant)]
#[cfg_attr(any(target_os = "android", target_env = "ohos"), expect(dead_code))]
pub(crate) enum ArgumentParsingResult {
    ChromeProcess(Opts, Preferences, ServoShellPreferences),
    ContentProcess(String),
    Exit,
    ErrorParsing,
}

enum ParseResolutionError {
    InvalidFormat,
    ZeroDimension,
    ParseError(std::num::ParseIntError),
}

impl fmt::Display for ParseResolutionError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ParseResolutionError::InvalidFormat => write!(f, "invalid resolution format"),
            ParseResolutionError::ZeroDimension => {
                write!(f, "width and height must be greater than 0")
            },
            ParseResolutionError::ParseError(e) => write!(f, "{e}"),
        }
    }
}

/// Parse a resolution string into a Size2D.
fn parse_resolution_string(
    string: String,
) -> Result<Option<Size2D<u32, DeviceIndependentPixel>>, ParseResolutionError> {
    if string.is_empty() {
        Ok(None)
    } else {
        let (width, height) = string
            .split_once(['x', 'X'])
            .ok_or(ParseResolutionError::InvalidFormat)?;

        let width = width.trim();
        let height = height.trim();
        if width.is_empty() || height.is_empty() {
            return Err(ParseResolutionError::InvalidFormat);
        }

        let width = width.parse().map_err(ParseResolutionError::ParseError)?;
        let height = height.parse().map_err(ParseResolutionError::ParseError)?;
        if width == 0 || height == 0 {
            return Err(ParseResolutionError::ZeroDimension);
        }

        Ok(Some(Size2D::new(width, height)))
    }
}

/// Parse a space or comma-separated list of stylesheet paths into a vector of
/// [`UserStyleSheet`].
fn parse_user_stylesheets(string: String) -> Result<Vec<Rc<UserStyleSheet>>, std::io::Error> {
    let mut results = Vec::new();
    for path_string in string.split([' ', ',']) {
        let path = env::current_dir()?.join(path_string);
        results.push(Rc::new(UserStyleSheet::new(
            read_to_string(&path)?,
            Url::from_file_path(&path).unwrap(),
        )));
    }
    Ok(results)
}

/// This is a helper function that fulfills the following parsing task
/// check for long/short cmd. If there is the flag with this
/// If the flag is not there, parse `None``
/// If the flag is there but no argument, parse `Some(default)`
/// If the flag is there and an argument parse the argument
fn flag_with_default_parser<S, T>(
    short_cmd: Option<char>,
    long_cmd: &'static str,
    argument_help: &'static str,
    help: &'static str,
    default: T,
    transform: fn(S) -> T,
) -> impl Parser<Option<T>>
where
    S: FromStr + 'static,
    <S as FromStr>::Err: fmt::Display,
    T: Clone + 'static,
{
    let just_flag = if let Some(c) = short_cmd {
        short(c).long(long_cmd)
    } else {
        long(long_cmd)
    }
    .req_flag(default)
    .hide();

    let arg = if let Some(c) = short_cmd {
        short(c).long(long_cmd)
    } else {
        long(long_cmd)
    }
    .argument::<S>(argument_help)
    .help(help)
    .map(transform);

    construct!([arg, just_flag]).optional()
}

fn profile() -> impl Parser<Option<OutputOptions>> {
    flag_with_default_parser(
        Some('p'),
        "profile",
        "",
        "uses 5.0 output as standard if no argument supplied",
        OutputOptions::Stdout(5.0),
        |val: String| {
            if let Ok(float) = val.parse::<f64>() {
                OutputOptions::Stdout(float)
            } else {
                OutputOptions::FileName(val)
            }
        },
    )
}

fn userscripts() -> impl Parser<Option<PathBuf>> {
    let arg = long("userscripts")
        .argument::<String>("your/directory")
        .help("Uses userscripts in specified full path")
        .map(PathBuf::from);

    construct!([arg]).optional()
}

fn webdriver_port() -> impl Parser<Option<u16>> {
    flag_with_default_parser(
        None,
        "webdriver",
        "7000",
        "Start remote WebDriver server on port",
        7000,
        |val| val,
    )
}

fn map_debug_options(arg: String) -> Vec<String> {
    arg.split(',').map(|s| s.to_owned()).collect()
}

#[derive(Bpaf, Clone, Debug)]
#[bpaf(options, version(VERSION), usage("servoshell [OPTIONS] URL"))]
// Newlines in comments are intentional to have the right formatting for the help message.
struct CmdArgs {
    /// Background Hang Monitor enabled.
    #[bpaf(short('B'), long("bhm"))]
    background_hang_monitor: bool,

    ///
    ///  Path to find SSL certificates.
    #[bpaf(argument("/home/servo/resources/certs"))]
    certificate_path: Option<PathBuf>,

    /// Do not shutdown until all threads have finished (macos only).
    #[bpaf(long)]
    clean_shutdown: bool,

    ///
    ///  Config directory following xdg spec on linux platform.
    #[bpaf(argument("~/.config/servo"))]
    config_dir: Option<PathBuf>,

    ///
    ///  Run as a content process and connect to the given pipe.
    #[bpaf(argument("servo-ipc-channel.abcdefg"))]
    content_process: Option<String>,

    ///
    ///  A comma-separated string of debug options. Pass help to show available options.
    #[bpaf(
        short('Z'),
        argument("layout_grid_enabled=true,dom_async_clipboard_enabled"),
        long,
        map(map_debug_options),
        fallback(vec![])
    )]
    debug: Vec<String>,

    ///
    ///  Device pixels per px.
    #[bpaf(argument("1.0"))]
    device_pixel_ratio: Option<f32>,

    /// Start remote devtools server on port listening on this address. <address>:<port> and <port> are valid values.
    #[bpaf(argument("127.0.0.1:7000"))]
    devtools: Option<String>,

    ///
    ///  Whether or not to enable experimental web platform features.
    #[bpaf(long)]
    enable_experimental_web_platform_features: bool,

    // Exit after Servo has loaded the page and detected a stable output image.
    #[bpaf(short('x'), long)]
    exit: bool,

    // Use ipc_channel in singleprocess mode.
    #[bpaf(short('I'), long("force-ipc"))]
    force_ipc: bool,

    /// Exit on thread failure instead of displaying about:failure.
    #[bpaf(short('f'), long)]
    hard_fail: bool,

    /// Headless mode.
    #[bpaf(short('z'), long)]
    headless: bool,

    ///
    /// Path to a hosts file (like `/etc/hosts`).
    /// Ignored if the `HOST_FILE` environment variable is set.
    #[bpaf(long("host-file"), argument("/path/to/hosts"))]
    host_file: Option<PathBuf>,

    ///
    ///  Whether or not to completely ignore certificate errors.
    #[bpaf(long)]
    ignore_certificate_errors: bool,

    /// Number of threads to use for layout.
    #[bpaf(short('y'), long, argument("1"))]
    layout_threads: Option<i64>,

    ///
    ///  Directory root with unminified scripts.
    #[bpaf(argument("~/.local/share/servo"))]
    local_script_source: Option<PathBuf>,

    #[cfg(target_env = "ohos")]
    /// Define a custom filter for logging.
    #[bpaf(argument("FILTER"))]
    log_filter: Option<String>,

    #[cfg(target_env = "ohos")]
    /// Also log to a file (/data/app/el2/100/base/org.servo.servo/cache/servo.log).
    #[bpaf(long)]
    log_to_file: bool,

    /// Run in multiprocess mode.
    #[bpaf(short('M'), long)]
    multiprocess: bool,

    /// Do not use native titlebar.
    #[bpaf(short('b'), long)]
    no_native_titlebar: bool,

    /// Path to an output image. The format of the image is determined by the extension.
    /// Supports all formats that `rust-image` does.
    #[bpaf(short('o'), argument("test.png"), long)]
    output: Option<PathBuf>,

    /// Time profiler flag and either a TSV output filename
    /// OR an interval for output to Stdout (blank for Stdout with interval of 5s).
    #[bpaf(external)]
    profile: Option<OutputOptions>,

    ///
    ///  Path to dump a self-contained HTML timeline of profiler traces.
    #[bpaf(argument("trace.html"), long)]
    profiler_trace_path: Option<PathBuf>,

    ///
    ///  A preference to set.
    #[bpaf(argument("dom_bluetooth_enabled"), many)]
    pref: Vec<String>,

    ///
    ///  Load in additional prefs from a file.
    #[bpaf(long, argument("/path/to/prefs.json"), many)]
    prefs_file: Vec<PathBuf>,

    ///
    ///  Probability of randomly closing a pipeline (for testing constellation hardening).
    #[bpaf(argument("0.25"))]
    random_pipeline_closure_probability: Option<f32>,

    /// A fixed seed for repeatbility of random pipeline closure.
    random_pipeline_closure_seed: Option<usize>,

    /// Run in a sandbox if multiprocess.
    #[bpaf(short('S'), long)]
    sandbox: bool,

    /// Shaders will be loaded from the specified directory instead of using the builtin ones.
    shaders: Option<PathBuf>,

    ///
    ///  Override the screen resolution in logical (device independent) pixels.
    #[bpaf(long("screen-size"), argument::<String>("1024x768"),
        parse(parse_resolution_string), fallback(None))]
    screen_size_override: Option<Size2D<u32, DeviceIndependentPixel>>,

    /// Use mouse events to simulate touch events. Left button presses will be converted to touch
    /// and mouse movements while the left button is pressed will be converted to touch movements.
    #[bpaf(long("simulate-touch-events"))]
    simulate_touch_events: bool,

    /// Use temporary storage (data on disk will not persist across restarts).
    #[bpaf(long)]
    temporary_storage: bool,
    /// Define a custom filter for traces. Overrides `SERVO_TRACING` if set.
    #[bpaf(long("tracing-filter"), argument("FILTER"))]
    tracing_filter: Option<String>,

    /// Unminify Javascript.
    #[bpaf(long)]
    unminify_js: bool,

    /// Unminify Css.
    #[bpaf(long)]
    unminify_css: bool,

    ///
    ///  Set custom user agent string (or ios / android / desktop for platform default).
    #[bpaf(short('u'),long,argument::<String>("NCSA mosaic/1.0 (X11;SunOS 4.1.4 sun4m"))]
    user_agent: Option<String>,

    ///
    ///  Uses userscripts in a specified full path.
    #[bpaf(external)]
    userscripts: Option<PathBuf>,

    ///
    /// Add each of the given UTF-8 encoded CSS files in the space or comma-separated
    /// list as user stylesheet to apply to every page loaded.
    #[bpaf(argument::<String>("file.css"), parse(parse_user_stylesheets),
    fallback(vec![]))]
    user_stylesheet: Vec<Rc<UserStyleSheet>>,

    /// Start remote WebDriver server on port.
    #[bpaf(external)]
    webdriver_port: Option<u16>,

    ///
    ///  Set the initial window size in logical (device independent) pixels.
    #[bpaf(argument::<String>("1024x740"), parse(parse_resolution_string), fallback(None))]
    window_size: Option<Size2D<u32, DeviceIndependentPixel>>,

    /// Set js_mem_gc_zeal_level=2 and js_mem_gc_zeal_frequency=1
    #[bpaf(long)]
    zealous_gc: bool,

    /// The url we should load.
    #[bpaf(positional("URL"), fallback(String::from("https://www.servo.org")))]
    url: String,
}

fn update_preferences_from_command_line_arguments(
    preferences: &mut Preferences,
    cmd_args: &CmdArgs,
) {
    if let Some(listen_address) = &cmd_args.devtools {
        preferences.devtools_server_enabled = true;
        preferences.devtools_server_listen_address = listen_address.clone();
    }

    if cmd_args.enable_experimental_web_platform_features {
        for pref in EXPERIMENTAL_PREFS {
            preferences.set_value(pref, PrefValue::Bool(true));
        }
    }

    for pref in &cmd_args.pref {
        let split: Vec<&str> = pref.splitn(2, '=').collect();
        let pref_name = split[0];
        let pref_value = PrefValue::from_booleanish_str(split.get(1).copied().unwrap_or("true"));
        preferences.set_value(pref_name, pref_value);
    }

    if let Some(layout_threads) = cmd_args.layout_threads {
        preferences.layout_threads = layout_threads;
    }

    if cmd_args.headless && preferences.media_glvideo_enabled {
        warn!("GL video rendering is not supported on headless windows.");
        preferences.media_glvideo_enabled = false;
    }

    if let Some(user_agent) = cmd_args.user_agent.clone() {
        preferences.user_agent = user_agent;
    }

    if cmd_args.webdriver_port.is_some() {
        preferences.dom_testing_html_input_element_select_files_enabled = true;
    }

    if cmd_args.zealous_gc {
        #[cfg(not(feature = "debugmozjs"))]
        warn!(
            "The zealous-gc option requires Servo to be compiled with debug-mozjs to take effect."
        );

        preferences.js_mem_gc_zeal_level = 2;
        preferences.js_mem_gc_zeal_frequency = 1;
    }
}

/// Parse Commandline arguments
///
/// Please note that e.g. `env::args` traditionally includes the binary name as the first
///  argument; However, the binary name must not be included in `args_without_binary`.
pub(crate) fn parse_command_line_arguments<'a>(
    args_without_binary: impl Into<Args<'a>>,
) -> ArgumentParsingResult {
    parse_arguments_helper(args_without_binary.into())
}
fn parse_arguments_helper(args_without_binary: Args) -> ArgumentParsingResult {
    let cmd_args = cmd_args().run_inner(args_without_binary);
    let cmd_args = match cmd_args {
        Ok(cmd_args) => cmd_args,
        Err(error) => {
            // Servo will exit after printing the parsing error, which makes the stdout / stderr
            // redirection via a seperate thread racy, so we log directly to the system logger.
            if cfg!(target_os = "android") || cfg!(target_env = "ohos") {
                match &error {
                    ParseFailure::Stderr(doc) => log::error!("{doc}"),
                    // '--help' will be parsed by the next one.
                    ParseFailure::Stdout(doc, _) => log::error!("{doc}"),
                    ParseFailure::Completion(_) => log::error!("Not supported on these platforms"),
                }
            } else {
                error.print_message(80);
            }

            return if error.exit_code() == 0 {
                ArgumentParsingResult::Exit
            } else {
                ArgumentParsingResult::ErrorParsing
            };
        },
    };

    // If this is the content process, we'll receive the real options over IPC. So fill in some dummy options for now.
    if let Some(content_process) = cmd_args.content_process {
        return ArgumentParsingResult::ContentProcess(content_process);
    }

    let config_dir = cmd_args
        .config_dir
        .clone()
        .or_else(default_config_dir)
        .inspect(|config_dir| {
            if !config_dir.exists() {
                fs::create_dir_all(config_dir).expect("Could not create config_dir");
            }
        });
    let temporary_storage = cmd_args.temporary_storage;
    if let Some(ref time_profiler_trace_path) = cmd_args.profiler_trace_path {
        let mut path = PathBuf::from(time_profiler_trace_path);
        path.pop();
        fs::create_dir_all(&path).expect("Error in creating profiler trace path");
    }

    let mut preferences = get_preferences(&cmd_args.prefs_file, &config_dir);

    update_preferences_from_command_line_arguments(&mut preferences, &cmd_args);

    // FIXME: enable JIT compilation on 32-bit Android after the startup crash issue (#31134) is fixed.
    if cfg!(target_os = "android") && cfg!(target_pointer_width = "32") {
        preferences.js_baseline_interpreter_enabled = false;
        preferences.js_baseline_jit_enabled = false;
        preferences.js_ion_enabled = false;
    }

    // Make sure the default window size is not larger than any provided screen size.
    let default_window_size = Size2D::new(1024, 740);
    let default_window_size = cmd_args
        .screen_size_override
        .map_or(default_window_size, |screen_size_override| {
            default_window_size.min(screen_size_override)
        });

    let servoshell_preferences = ServoShellPreferences {
        url: Some(cmd_args.url),
        no_native_titlebar: cmd_args.no_native_titlebar,
        device_pixel_ratio_override: cmd_args.device_pixel_ratio,
        clean_shutdown: cmd_args.clean_shutdown,
        headless: cmd_args.headless,
        tracing_filter: cmd_args.tracing_filter,
        initial_window_size: cmd_args.window_size.unwrap_or(default_window_size),
        screen_size_override: cmd_args.screen_size_override,
        simulate_touch_events: cmd_args.simulate_touch_events,
        webdriver_port: Cell::new(cmd_args.webdriver_port),
        output_image_path: cmd_args.output.map(|p| p.to_string_lossy().into_owned()),
        exit_after_stable_image: cmd_args.exit,
        userscripts_directory: cmd_args.userscripts,
        user_stylesheets: cmd_args.user_stylesheet,
        experimental_preferences_enabled: cmd_args.enable_experimental_web_platform_features,
        #[cfg(target_env = "ohos")]
        log_filter: cmd_args.log_filter.or_else(|| {
            (!preferences.log_filter.is_empty()).then(|| preferences.log_filter.clone())
        }),
        #[cfg(target_env = "ohos")]
        log_to_file: cmd_args.log_to_file,
        ..Default::default()
    };

    let Ok(debug_options) = parse_diagnostics_logging(cmd_args.debug) else {
        return ArgumentParsingResult::ErrorParsing;
    };

    #[cfg(not(feature = "multiprocess"))]
    if cmd_args.multiprocess || cmd_args.force_ipc {
        log::error!("IPC was disabled at compile time. IPC and multiprocess modes are disabled");
    }

    let opts = Opts {
        debug: debug_options,
        time_profiling: cmd_args.profile,
        time_profiler_trace_path: cmd_args
            .profiler_trace_path
            .map(|p| p.to_string_lossy().into_owned()),
        hard_fail: cmd_args.hard_fail,
        multiprocess: cmd_args.multiprocess,
        background_hang_monitor: cmd_args.background_hang_monitor,
        sandbox: cmd_args.sandbox,
        random_pipeline_closure_probability: cmd_args.random_pipeline_closure_probability,
        random_pipeline_closure_seed: cmd_args.random_pipeline_closure_seed,
        config_dir,
        temporary_storage,
        shaders_path: cmd_args.shaders,
        certificate_path: cmd_args
            .certificate_path
            .map(|p| p.to_string_lossy().into_owned()),
        host_file: cmd_args.host_file,
        ignore_certificate_errors: cmd_args.ignore_certificate_errors,
        unminify_js: cmd_args.unminify_js,
        local_script_source: cmd_args
            .local_script_source
            .map(|p| p.to_string_lossy().into_owned()),
        unminify_css: cmd_args.unminify_css,
        force_ipc: cmd_args.force_ipc,
    };

    ArgumentParsingResult::ChromeProcess(opts, preferences, servoshell_preferences)
}

/// Parse the '-Z' command-line flags.
fn parse_diagnostics_logging(cli_options: Vec<String>) -> Result<DiagnosticsLogging, ()> {
    fn print_option(name: &str, description: &str) {
        println!("\t{:<35} {}", name, description);
    }

    if cli_options.contains(&"help".into()) {
        // TODO: Remove hardcoded binary name by perhaps receiving this as an argument.
        println!("Usage: servoshell -Z option,[option,...]\n\twhere options include:");
        print_option("help", "Show this help message");
        for option in DiagnosticsLoggingOption::iter() {
            print_option(option.help_option(), option.help_message())
        }

        std::process::exit(0);
    }

    let mut diagnostics_logging = DiagnosticsLogging::new();
    for cli_option in cli_options.iter() {
        if let Err(error) = diagnostics_logging.extend_from_string(cli_option) {
            eprintln!("Could not parse debug logging option: {error}");
            return Err(());
        }
    }

    Ok(diagnostics_logging)
}

#[cfg(test)]
fn test_parse_pref(arg: &str) -> Preferences {
    let args = ["--pref", arg];
    match parse_command_line_arguments(args.as_slice()) {
        ArgumentParsingResult::ContentProcess(..) => {
            unreachable!("No preferences for content process")
        },
        ArgumentParsingResult::ChromeProcess(_, preferences, _) => preferences,
        ArgumentParsingResult::Exit => {
            panic!("we supplied a --pref argument above which should be parsed")
        },
        ArgumentParsingResult::ErrorParsing => {
            unreachable!("we supplied a --pref argument above which should be parsed")
        },
    }
}

#[test]
fn test_parse_pref_from_command_line() {
    // Test with boolean values.
    let preferences = test_parse_pref("dom_bluetooth_enabled=true");
    assert!(preferences.dom_bluetooth_enabled);

    let preferences = test_parse_pref("dom_bluetooth_enabled=false");
    assert!(!preferences.dom_bluetooth_enabled);

    // Test with numbers
    let preferences = test_parse_pref("layout_threads=42");
    assert_eq!(preferences.layout_threads, 42);

    // Test with unsigned numbers
    let preferences = test_parse_pref("network_http_cache_size=50");
    assert_eq!(preferences.network_http_cache_size, 50);
    let preferences = test_parse_pref("network_connection_timeout=30");
    assert_eq!(preferences.network_connection_timeout, 30);

    // Test string.
    let preferences = test_parse_pref("fonts_default=Lucida");
    assert_eq!(preferences.fonts_default, "Lucida");

    // Test with no value (defaults to true).
    let preferences = test_parse_pref("dom_bluetooth_enabled");
    assert!(preferences.dom_bluetooth_enabled);
}

#[test]
fn test_invalid_prefs_from_command_line_panics() {
    let err_msg = std::panic::catch_unwind(|| {
        test_parse_pref("doesntexist=true");
    })
    .err()
    .and_then(|a| a.downcast_ref::<String>().cloned())
    .expect("Should panic");
    assert_eq!(
        err_msg, "Unknown preference: \"doesntexist\"",
        "Message should describe the problem"
    )
}

#[test]
fn test_create_prefs_map() {
    let json_str = "{
        \"layout.writing-mode.enabled\": true,
        \"network.mime.sniff\": false,
        \"shell.homepage\": \"https://servo.org\"
    }";
    assert_eq!(read_prefs_map(json_str).len(), 3);
}

#[cfg(test)]
fn test_parse(arg: &str) -> (Opts, Preferences, ServoShellPreferences) {
    // bpaf requires the arguments that are separated by whitespace to be different elements of the vector.
    let args_split: Vec<&str> = arg.split_whitespace().collect();
    match parse_command_line_arguments(args_split.as_slice()) {
        ArgumentParsingResult::ContentProcess(..) => {
            unreachable!("No preferences for content process")
        },
        ArgumentParsingResult::ChromeProcess(opts, preferences, servoshell_preferences) => {
            (opts, preferences, servoshell_preferences)
        },
        ArgumentParsingResult::Exit | ArgumentParsingResult::ErrorParsing => {
            unreachable!("We always have valid preference in our test cases")
        },
    }
}

#[test]
fn test_profiling_args() {
    assert_eq!(
        test_parse("-p").0.time_profiling.unwrap(),
        OutputOptions::Stdout(5_f64)
    );

    assert_eq!(
        test_parse("-p 10").0.time_profiling.unwrap(),
        OutputOptions::Stdout(10_f64)
    );

    assert_eq!(
        test_parse("-p 10.0").0.time_profiling.unwrap(),
        OutputOptions::Stdout(10_f64)
    );

    assert_eq!(
        test_parse("-p foo.txt").0.time_profiling.unwrap(),
        OutputOptions::FileName(String::from("foo.txt"))
    );
}

#[test]
fn test_servoshell_cmd() {
    assert_eq!(
        test_parse("--screen-size=1000x1000")
            .2
            .screen_size_override
            .unwrap(),
        Size2D::new(1000, 1000)
    );

    assert_eq!(
        test_parse("--certificate-path=/tmp/test")
            .0
            .certificate_path
            .unwrap(),
        String::from("/tmp/test")
    );

    assert!({
        let p = test_parse("--zealous-gc").1;
        p.js_mem_gc_zeal_level == 2 && p.js_mem_gc_zeal_frequency == 1
    });
}