mirror of
https://github.com/servo/servo.git
synced 2025-06-06 16:45:39 +00:00
55f908653f
These tests don't seem to time out any longer and this mechanism is probably better served by some sort of adjustment to `RUST_LOG` in the WPT harness.
804 lines
27 KiB
Rust
804 lines
27 KiB
Rust
/* 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/. */
|
|
|
|
//! Configuration options for a single run of the servo application. Created
|
|
//! from command line arguments.
|
|
|
|
use std::default::Default;
|
|
use std::fs::{self, File};
|
|
use std::io::Read;
|
|
use std::path::{Path, PathBuf};
|
|
use std::sync::atomic::{AtomicBool, Ordering};
|
|
use std::sync::{RwLock, RwLockReadGuard};
|
|
use std::{env, process};
|
|
|
|
use euclid::Size2D;
|
|
use getopts::{Matches, Options};
|
|
use lazy_static::lazy_static;
|
|
use log::error;
|
|
use serde::{Deserialize, Serialize};
|
|
use servo_geometry::DeviceIndependentPixel;
|
|
use servo_url::ServoUrl;
|
|
use url::{self, Url};
|
|
|
|
use crate::{pref, set_pref};
|
|
|
|
/// Global flags for Servo, currently set on the command line.
|
|
#[derive(Clone, Debug, Deserialize, Serialize)]
|
|
pub struct Opts {
|
|
/// Whether or not the legacy layout system is enabled.
|
|
pub legacy_layout: bool,
|
|
|
|
/// The maximum size of each tile in pixels (`-s`).
|
|
pub tile_size: usize,
|
|
|
|
/// `None` to disable the time profiler or `Some` to enable it with:
|
|
///
|
|
/// - an interval in seconds to cause it to produce output on that interval.
|
|
/// (`i.e. -p 5`).
|
|
/// - a file path to write profiling info to a TSV file upon Servo's termination.
|
|
/// (`i.e. -p out.tsv`).
|
|
pub time_profiling: Option<OutputOptions>,
|
|
|
|
/// When the profiler is enabled, this is an optional path to dump a self-contained HTML file
|
|
/// visualizing the traces as a timeline.
|
|
pub time_profiler_trace_path: Option<String>,
|
|
|
|
/// `None` to disable the memory profiler or `Some` with an interval in seconds to enable it
|
|
/// and cause it to produce output on that interval (`-m`).
|
|
pub mem_profiler_period: Option<f64>,
|
|
|
|
/// True to turn off incremental layout.
|
|
pub nonincremental_layout: bool,
|
|
|
|
/// Where to load userscripts from, if any. An empty string will load from
|
|
/// the resources/user-agent-js directory, and if the option isn't passed userscripts
|
|
/// won't be loaded
|
|
pub userscripts: Option<String>,
|
|
|
|
pub user_stylesheets: Vec<(Vec<u8>, ServoUrl)>,
|
|
|
|
pub output_file: Option<String>,
|
|
|
|
pub headless: bool,
|
|
|
|
/// True to exit on thread failure instead of displaying about:failure.
|
|
pub hard_fail: bool,
|
|
|
|
/// Debug options that are used by developers to control Servo
|
|
/// behavior for debugging purposes.
|
|
pub debug: DebugOptions,
|
|
|
|
/// Port number to start a server to listen to remote Firefox devtools connections.
|
|
/// 0 for random port.
|
|
pub devtools_port: u16,
|
|
|
|
/// Start the devtools server at startup
|
|
pub devtools_server_enabled: bool,
|
|
|
|
/// `None` to disable WebDriver or `Some` with a port number to start a server to listen to
|
|
/// remote WebDriver commands.
|
|
pub webdriver_port: Option<u16>,
|
|
|
|
/// The initial requested size of the window.
|
|
pub initial_window_size: Size2D<u32, DeviceIndependentPixel>,
|
|
|
|
/// Whether we're running in multiprocess mode.
|
|
pub multiprocess: bool,
|
|
|
|
/// Whether we want background hang monitor enabled or not
|
|
pub background_hang_monitor: bool,
|
|
|
|
/// Whether we're running inside the sandbox.
|
|
pub sandbox: bool,
|
|
|
|
/// Probability of randomly closing a pipeline,
|
|
/// used for testing the hardening of the constellation.
|
|
pub random_pipeline_closure_probability: Option<f32>,
|
|
|
|
/// The seed for the RNG used to randomly close pipelines,
|
|
/// used for testing the hardening of the constellation.
|
|
pub random_pipeline_closure_seed: Option<usize>,
|
|
|
|
/// True to exit after the page load (`-x`).
|
|
pub exit_after_load: bool,
|
|
|
|
/// Load shaders from disk.
|
|
pub shaders_dir: Option<PathBuf>,
|
|
|
|
/// Directory for a default config directory
|
|
pub config_dir: Option<PathBuf>,
|
|
|
|
/// Print the version and exit.
|
|
pub is_printing_version: bool,
|
|
|
|
/// Path to PEM encoded SSL CA certificate store.
|
|
pub certificate_path: Option<String>,
|
|
|
|
/// Whether or not to completely ignore SSL certificate validation errors.
|
|
/// TODO: We should see if we can eliminate the need for this by fixing
|
|
/// <https://github.com/servo/servo/issues/30080>.
|
|
pub ignore_certificate_errors: bool,
|
|
|
|
/// Unminify Javascript.
|
|
pub unminify_js: bool,
|
|
|
|
/// Directory path that was created with "unminify-js"
|
|
pub local_script_source: Option<String>,
|
|
|
|
/// Print Progressive Web Metrics to console.
|
|
pub print_pwm: bool,
|
|
|
|
/// True to enable minibrowser
|
|
pub minibrowser: bool,
|
|
}
|
|
|
|
fn print_usage(app: &str, opts: &Options) {
|
|
let message = format!(
|
|
"Usage: {} [ options ... ] [URL]\n\twhere options include",
|
|
app
|
|
);
|
|
println!("{}", opts.usage(&message));
|
|
}
|
|
|
|
/// Debug options for Servo, currently set on the command line with -Z
|
|
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
|
|
pub struct DebugOptions {
|
|
/// List all the debug options.
|
|
pub help: bool,
|
|
|
|
/// True if we should bubble intrinsic widths sequentially. If this is true,
|
|
/// then intrinsic widths are computed as a separate pass instead of during
|
|
/// flow construction. You may wish to turn this flag on in order to
|
|
/// benchmark style recalculation against other browser engines.
|
|
pub bubble_inline_sizes_separately: bool,
|
|
|
|
/// If set with `disable-text-aa`, disable antialiasing on fonts. This is
|
|
/// primarily useful for reftests where pixel perfect results are required
|
|
/// when using fonts such as the Ahem font for layout tests.
|
|
pub disable_text_antialiasing: bool,
|
|
|
|
/// Disable subpixel antialiasing of rendered text.
|
|
pub disable_subpixel_text_antialiasing: bool,
|
|
|
|
/// Disable antialiasing of rendered text on the HTML canvas element.
|
|
/// If set with `disable-canvas-aa`, disable antialiasing on the HTML canvas
|
|
/// element. Like `disable-text-aa`, this is useful for reftests where
|
|
/// pixel perfect results are required.
|
|
pub disable_canvas_antialiasing: bool,
|
|
|
|
/// Print the DOM after each restyle.
|
|
pub dump_style_tree: bool,
|
|
|
|
/// Dumps the rule tree.
|
|
pub dump_rule_tree: bool,
|
|
|
|
/// Print the flow tree (Layout 2013) or fragment tree (Layout 2020) after each layout.
|
|
pub dump_flow_tree: bool,
|
|
|
|
/// Print the stacking context tree after each layout.
|
|
pub dump_stacking_context_tree: bool,
|
|
|
|
/// Print the display list after each layout.
|
|
pub dump_display_list: bool,
|
|
|
|
/// Print the display list in JSON form.
|
|
pub dump_display_list_json: bool,
|
|
|
|
/// Print notifications when there is a relayout.
|
|
pub relayout_event: bool,
|
|
|
|
/// Periodically print out on which events script threads spend their processing time.
|
|
pub profile_script_events: bool,
|
|
|
|
/// Paint borders along fragment boundaries.
|
|
pub show_fragment_borders: bool,
|
|
|
|
/// Mark which thread laid each flow out with colors.
|
|
pub show_parallel_layout: bool,
|
|
|
|
/// True if each step of layout is traced to an external JSON file
|
|
/// for debugging purposes. Setting this implies sequential layout
|
|
/// and paint.
|
|
pub trace_layout: bool,
|
|
|
|
/// Disable the style sharing cache.
|
|
pub disable_share_style_cache: bool,
|
|
|
|
/// Whether to show in stdout style sharing cache stats after a restyle.
|
|
pub dump_style_statistics: bool,
|
|
|
|
/// Translate mouse input into touch events.
|
|
pub convert_mouse_to_touch: bool,
|
|
|
|
/// Replace unpaires surrogates in DOM strings with U+FFFD.
|
|
/// See <https://github.com/servo/servo/issues/6564>
|
|
pub replace_surrogates: bool,
|
|
|
|
/// Log GC passes and their durations.
|
|
pub gc_profile: bool,
|
|
|
|
/// Load web fonts synchronously to avoid non-deterministic network-driven reflows.
|
|
pub load_webfonts_synchronously: bool,
|
|
|
|
/// Show webrender profiling stats on screen.
|
|
pub webrender_stats: bool,
|
|
|
|
/// True to compile all webrender shaders at init time. This is mostly
|
|
/// useful when modifying the shaders, to ensure they all compile
|
|
/// after each change is made.
|
|
pub precache_shaders: bool,
|
|
|
|
/// True to use OS native signposting facilities. This makes profiling events (script activity,
|
|
/// reflow, compositing, etc.) appear in Instruments.app on macOS.
|
|
pub signpost: bool,
|
|
}
|
|
|
|
impl DebugOptions {
|
|
pub fn extend(&mut self, debug_string: String) -> Result<(), String> {
|
|
for option in debug_string.split(',') {
|
|
match option {
|
|
"help" => self.help = true,
|
|
"bubble-inline-sizes-separately" => self.bubble_inline_sizes_separately = true,
|
|
"convert-mouse-to-touch" => self.convert_mouse_to_touch = true,
|
|
"disable-canvas-aa" => self.disable_canvas_antialiasing = true,
|
|
"disable-share-style-cache" => self.disable_share_style_cache = true,
|
|
"disable-subpixel-aa" => self.disable_subpixel_text_antialiasing = true,
|
|
"disable-text-aa" => self.disable_text_antialiasing = true,
|
|
"dump-display-list" => self.dump_display_list = true,
|
|
"dump-display-list-json" => self.dump_display_list_json = true,
|
|
"dump-stacking-context-tree" => self.dump_stacking_context_tree = true,
|
|
"dump-flow-tree" => self.dump_flow_tree = true,
|
|
"dump-rule-tree" => self.dump_rule_tree = true,
|
|
"dump-style-tree" => self.dump_style_tree = true,
|
|
"gc-profile" => self.gc_profile = true,
|
|
"load-webfonts-synchronously" => self.load_webfonts_synchronously = true,
|
|
"precache-shaders" => self.precache_shaders = true,
|
|
"profile-script-events" => self.profile_script_events = true,
|
|
"relayout-event" => self.relayout_event = true,
|
|
"replace-surrogates" => self.replace_surrogates = true,
|
|
"show-fragment-borders" => self.show_fragment_borders = true,
|
|
"show-parallel-layout" => self.show_parallel_layout = true,
|
|
"signpost" => self.signpost = true,
|
|
"dump-style-stats" => self.dump_style_statistics = true,
|
|
"trace-layout" => self.trace_layout = true,
|
|
"wr-stats" => self.webrender_stats = true,
|
|
"" => {},
|
|
_ => return Err(String::from(option)),
|
|
};
|
|
}
|
|
|
|
if self.trace_layout {
|
|
self.bubble_inline_sizes_separately = true;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn print_usage(app: &str) {
|
|
fn print_option(name: &str, description: &str) {
|
|
println!("\t{:<35} {}", name, description);
|
|
}
|
|
|
|
println!(
|
|
"Usage: {} debug option,[options,...]\n\twhere options include\n\nOptions:",
|
|
app
|
|
);
|
|
|
|
print_option(
|
|
"bubble-inline-sizes-separately",
|
|
"Bubble intrinsic widths separately like other engines.",
|
|
);
|
|
print_option(
|
|
"convert-mouse-to-touch",
|
|
"Send touch events instead of mouse events",
|
|
);
|
|
print_option(
|
|
"disable-canvas-aa",
|
|
"Disable antialiasing on the HTML canvas element.",
|
|
);
|
|
print_option(
|
|
"disable-share-style-cache",
|
|
"Disable the style sharing cache.",
|
|
);
|
|
print_option(
|
|
"disable-subpixel-aa",
|
|
"Disable subpixel text antialiasing overriding preference.",
|
|
);
|
|
print_option("disable-text-aa", "Disable antialiasing of rendered text.");
|
|
print_option(
|
|
"dump-stacking-context-tree",
|
|
"Print the stacking context tree after each layout.",
|
|
);
|
|
print_option(
|
|
"dump-display-list",
|
|
"Print the display list after each layout.",
|
|
);
|
|
print_option(
|
|
"dump-display-list-json",
|
|
"Print the display list in JSON form.",
|
|
);
|
|
print_option(
|
|
"dump-flow-tree",
|
|
"Print the flow tree (Layout 2013) or fragment tree (Layout 2020) after each layout.",
|
|
);
|
|
print_option(
|
|
"dump-rule-tree",
|
|
"Print the style rule tree after each layout.",
|
|
);
|
|
print_option(
|
|
"dump-style-tree",
|
|
"Print the DOM with computed styles after each restyle.",
|
|
);
|
|
print_option("dump-style-stats", "Print style statistics each restyle.");
|
|
print_option("gc-profile", "Log GC passes and their durations.");
|
|
print_option(
|
|
"load-webfonts-synchronously",
|
|
"Load web fonts synchronously to avoid non-deterministic network-driven reflows",
|
|
);
|
|
print_option(
|
|
"parallel-display-list-building",
|
|
"Build display lists in parallel.",
|
|
);
|
|
print_option("precache-shaders", "Compile all shaders during init.");
|
|
print_option(
|
|
"profile-script-events",
|
|
"Enable profiling of script-related events.",
|
|
);
|
|
print_option(
|
|
"relayout-event",
|
|
"Print notifications when there is a relayout.",
|
|
);
|
|
print_option("replace-surrogates", "Replace unpaires surrogates in DOM strings with U+FFFD. See https://github.com/servo/servo/issues/6564");
|
|
print_option(
|
|
"show-fragment-borders",
|
|
"Paint borders along fragment boundaries.",
|
|
);
|
|
print_option(
|
|
"show-parallel-layout",
|
|
"Mark which thread laid each flow out with colors.",
|
|
);
|
|
print_option(
|
|
"signpost",
|
|
"Emit native OS signposts for profile events (currently macOS only)",
|
|
);
|
|
print_option(
|
|
"trace-layout",
|
|
"Write layout trace to an external file for debugging.",
|
|
);
|
|
print_option("wr-stats", "Show WebRender profiler on screen.");
|
|
|
|
println!();
|
|
|
|
process::exit(0)
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, Deserialize, Serialize)]
|
|
pub enum OutputOptions {
|
|
/// Database connection config (hostname, name, user, pass)
|
|
FileName(String),
|
|
Stdout(f64),
|
|
}
|
|
|
|
fn args_fail(msg: &str) -> ! {
|
|
eprintln!("{}", msg);
|
|
process::exit(1)
|
|
}
|
|
|
|
static MULTIPROCESS: AtomicBool = AtomicBool::new(false);
|
|
|
|
#[inline]
|
|
pub fn multiprocess() -> bool {
|
|
MULTIPROCESS.load(Ordering::Relaxed)
|
|
}
|
|
|
|
pub fn default_opts() -> Opts {
|
|
Opts {
|
|
legacy_layout: false,
|
|
tile_size: 512,
|
|
time_profiling: None,
|
|
time_profiler_trace_path: None,
|
|
mem_profiler_period: None,
|
|
nonincremental_layout: false,
|
|
userscripts: None,
|
|
user_stylesheets: Vec::new(),
|
|
output_file: None,
|
|
headless: false,
|
|
hard_fail: true,
|
|
devtools_port: 0,
|
|
devtools_server_enabled: false,
|
|
webdriver_port: None,
|
|
initial_window_size: Size2D::new(1024, 740),
|
|
multiprocess: false,
|
|
background_hang_monitor: false,
|
|
random_pipeline_closure_probability: None,
|
|
random_pipeline_closure_seed: None,
|
|
sandbox: false,
|
|
debug: Default::default(),
|
|
exit_after_load: false,
|
|
config_dir: None,
|
|
is_printing_version: false,
|
|
shaders_dir: None,
|
|
certificate_path: None,
|
|
ignore_certificate_errors: false,
|
|
unminify_js: false,
|
|
local_script_source: None,
|
|
print_pwm: false,
|
|
minibrowser: true,
|
|
}
|
|
}
|
|
|
|
pub fn from_cmdline_args(mut opts: Options, args: &[String]) -> ArgumentParsingResult {
|
|
let (app_name, args) = args.split_first().unwrap();
|
|
|
|
opts.optflag("", "legacy-layout", "Use the legacy layout engine");
|
|
opts.optopt("o", "output", "Output file", "output.png");
|
|
opts.optopt("s", "size", "Size of tiles", "512");
|
|
opts.optflagopt(
|
|
"p",
|
|
"profile",
|
|
"Time profiler flag and either a TSV output filename \
|
|
OR an interval for output to Stdout (blank for Stdout with interval of 5s)",
|
|
"10 \
|
|
OR time.tsv",
|
|
);
|
|
opts.optflagopt(
|
|
"",
|
|
"profiler-trace-path",
|
|
"Path to dump a self-contained HTML timeline of profiler traces",
|
|
"",
|
|
);
|
|
opts.optflagopt(
|
|
"m",
|
|
"memory-profile",
|
|
"Memory profiler flag and output interval",
|
|
"10",
|
|
);
|
|
opts.optflag("x", "exit", "Exit after load flag");
|
|
opts.optopt(
|
|
"y",
|
|
"layout-threads",
|
|
"Number of threads to use for layout",
|
|
"1",
|
|
);
|
|
opts.optflag(
|
|
"i",
|
|
"nonincremental-layout",
|
|
"Enable to turn off incremental layout.",
|
|
);
|
|
opts.optflagopt(
|
|
"",
|
|
"userscripts",
|
|
"Uses userscripts in resources/user-agent-js, or a specified full path",
|
|
"",
|
|
);
|
|
opts.optmulti(
|
|
"",
|
|
"user-stylesheet",
|
|
"A user stylesheet to be added to every document",
|
|
"file.css",
|
|
);
|
|
opts.optopt(
|
|
"",
|
|
"shaders",
|
|
"Shaders will be loaded from the specified directory instead of using the builtin ones.",
|
|
"",
|
|
);
|
|
opts.optflag("z", "headless", "Headless mode");
|
|
opts.optflag(
|
|
"f",
|
|
"hard-fail",
|
|
"Exit on thread failure instead of displaying about:failure",
|
|
);
|
|
opts.optflag(
|
|
"F",
|
|
"soft-fail",
|
|
"Display about:failure on thread failure instead of exiting",
|
|
);
|
|
opts.optflagopt("", "devtools", "Start remote devtools server on port", "0");
|
|
opts.optflagopt(
|
|
"",
|
|
"webdriver",
|
|
"Start remote WebDriver server on port",
|
|
"7000",
|
|
);
|
|
opts.optopt("", "resolution", "Set window resolution.", "1024x740");
|
|
opts.optflag("M", "multiprocess", "Run in multiprocess mode");
|
|
opts.optflag("B", "bhm", "Background Hang Monitor enabled");
|
|
opts.optflag("S", "sandbox", "Run in a sandbox if multiprocess");
|
|
opts.optopt(
|
|
"",
|
|
"random-pipeline-closure-probability",
|
|
"Probability of randomly closing a pipeline (for testing constellation hardening).",
|
|
"0.0",
|
|
);
|
|
opts.optopt(
|
|
"",
|
|
"random-pipeline-closure-seed",
|
|
"A fixed seed for repeatbility of random pipeline closure.",
|
|
"",
|
|
);
|
|
opts.optmulti(
|
|
"Z",
|
|
"debug",
|
|
"A comma-separated string of debug options. Pass help to show available options.",
|
|
"",
|
|
);
|
|
opts.optflag("h", "help", "Print this message");
|
|
opts.optopt(
|
|
"",
|
|
"resources-path",
|
|
"Path to find static resources",
|
|
"/home/servo/resources",
|
|
);
|
|
opts.optopt(
|
|
"",
|
|
"certificate-path",
|
|
"Path to find SSL certificates",
|
|
"/home/servo/resources/certs",
|
|
);
|
|
opts.optflag(
|
|
"",
|
|
"ignore-certificate-errors",
|
|
"Whether or not to completely ignore certificate errors",
|
|
);
|
|
opts.optopt(
|
|
"",
|
|
"content-process",
|
|
"Run as a content process and connect to the given pipe",
|
|
"servo-ipc-channel.abcdefg",
|
|
);
|
|
opts.optopt(
|
|
"",
|
|
"config-dir",
|
|
"config directory following xdg spec on linux platform",
|
|
"",
|
|
);
|
|
opts.optflag("v", "version", "Display servo version information");
|
|
opts.optflag("", "unminify-js", "Unminify Javascript");
|
|
opts.optflag("", "print-pwm", "Print Progressive Web Metrics");
|
|
opts.optopt(
|
|
"",
|
|
"local-script-source",
|
|
"Directory root with unminified scripts",
|
|
"",
|
|
);
|
|
opts.optflag("", "no-minibrowser", "Open minibrowser");
|
|
|
|
let opt_match = match opts.parse(args) {
|
|
Ok(m) => m,
|
|
Err(f) => args_fail(&f.to_string()),
|
|
};
|
|
|
|
if opt_match.opt_present("h") || opt_match.opt_present("help") {
|
|
print_usage(app_name, &opts);
|
|
process::exit(0);
|
|
};
|
|
|
|
// If this is the content process, we'll receive the real options over IPC. So just fill in
|
|
// some dummy options for now.
|
|
if let Some(content_process) = opt_match.opt_str("content-process") {
|
|
MULTIPROCESS.store(true, Ordering::SeqCst);
|
|
return ArgumentParsingResult::ContentProcess(opt_match, content_process);
|
|
}
|
|
|
|
let mut debug_options = DebugOptions::default();
|
|
for debug_string in opt_match.opt_strs("Z") {
|
|
if let Err(e) = debug_options.extend(debug_string) {
|
|
args_fail(&format!("error: unrecognized debug option: {}", e));
|
|
}
|
|
}
|
|
|
|
if debug_options.help {
|
|
DebugOptions::print_usage(app_name)
|
|
}
|
|
|
|
let tile_size: usize = match opt_match.opt_str("s") {
|
|
Some(tile_size_str) => tile_size_str
|
|
.parse()
|
|
.unwrap_or_else(|err| args_fail(&format!("Error parsing option: -s ({})", err))),
|
|
None => 512,
|
|
};
|
|
|
|
// If only the flag is present, default to a 5 second period for both profilers
|
|
let time_profiling = if opt_match.opt_present("p") {
|
|
match opt_match.opt_str("p") {
|
|
Some(argument) => match argument.parse::<f64>() {
|
|
Ok(interval) => Some(OutputOptions::Stdout(interval)),
|
|
Err(_) => match ServoUrl::parse(&argument) {
|
|
Ok(_) => panic!("influxDB isn't supported anymore"),
|
|
Err(_) => Some(OutputOptions::FileName(argument)),
|
|
},
|
|
},
|
|
None => Some(OutputOptions::Stdout(5.0)),
|
|
}
|
|
} else {
|
|
// if the p option doesn't exist:
|
|
None
|
|
};
|
|
|
|
if let Some(ref time_profiler_trace_path) = opt_match.opt_str("profiler-trace-path") {
|
|
let mut path = PathBuf::from(time_profiler_trace_path);
|
|
path.pop();
|
|
if let Err(why) = fs::create_dir_all(&path) {
|
|
error!(
|
|
"Couldn't create/open {:?}: {:?}",
|
|
Path::new(time_profiler_trace_path).to_string_lossy(),
|
|
why
|
|
);
|
|
}
|
|
}
|
|
|
|
let mem_profiler_period = opt_match.opt_default("m", "5").map(|period| {
|
|
period
|
|
.parse()
|
|
.unwrap_or_else(|err| args_fail(&format!("Error parsing option: -m ({})", err)))
|
|
});
|
|
|
|
let mut layout_threads: Option<usize> = opt_match.opt_str("y").map(|layout_threads_str| {
|
|
layout_threads_str
|
|
.parse()
|
|
.unwrap_or_else(|err| args_fail(&format!("Error parsing option: -y ({})", err)))
|
|
});
|
|
|
|
let nonincremental_layout = opt_match.opt_present("i");
|
|
|
|
let random_pipeline_closure_probability = opt_match
|
|
.opt_str("random-pipeline-closure-probability")
|
|
.map(|prob| {
|
|
prob.parse().unwrap_or_else(|err| {
|
|
args_fail(&format!(
|
|
"Error parsing option: --random-pipeline-closure-probability ({})",
|
|
err
|
|
))
|
|
})
|
|
});
|
|
|
|
let random_pipeline_closure_seed =
|
|
opt_match
|
|
.opt_str("random-pipeline-closure-seed")
|
|
.map(|seed| {
|
|
seed.parse().unwrap_or_else(|err| {
|
|
args_fail(&format!(
|
|
"Error parsing option: --random-pipeline-closure-seed ({})",
|
|
err
|
|
))
|
|
})
|
|
});
|
|
|
|
if debug_options.trace_layout {
|
|
layout_threads = Some(1);
|
|
}
|
|
|
|
let (devtools_server_enabled, devtools_port) = if opt_match.opt_present("devtools") {
|
|
let port = opt_match
|
|
.opt_str("devtools")
|
|
.map(|port| {
|
|
port.parse().unwrap_or_else(|err| {
|
|
args_fail(&format!("Error parsing option: --devtools ({})", err))
|
|
})
|
|
})
|
|
.unwrap_or(pref!(devtools.server.port));
|
|
(true, port as u16)
|
|
} else {
|
|
(
|
|
pref!(devtools.server.enabled),
|
|
pref!(devtools.server.port) as u16,
|
|
)
|
|
};
|
|
|
|
let webdriver_port = opt_match.opt_default("webdriver", "7000").map(|port| {
|
|
port.parse().unwrap_or_else(|err| {
|
|
args_fail(&format!("Error parsing option: --webdriver ({})", err))
|
|
})
|
|
});
|
|
|
|
let initial_window_size = match opt_match.opt_str("resolution") {
|
|
Some(res_string) => {
|
|
let res: Vec<u32> = res_string
|
|
.split('x')
|
|
.map(|r| {
|
|
r.parse().unwrap_or_else(|err| {
|
|
args_fail(&format!("Error parsing option: --resolution ({})", err))
|
|
})
|
|
})
|
|
.collect();
|
|
Size2D::new(res[0], res[1])
|
|
},
|
|
None => Size2D::new(1024, 740),
|
|
};
|
|
|
|
if opt_match.opt_present("M") {
|
|
MULTIPROCESS.store(true, Ordering::SeqCst)
|
|
}
|
|
|
|
let user_stylesheets = opt_match
|
|
.opt_strs("user-stylesheet")
|
|
.iter()
|
|
.map(|filename| {
|
|
let cwd = env::current_dir().unwrap();
|
|
let path = cwd.join(filename);
|
|
let url = ServoUrl::from_url(Url::from_file_path(&path).unwrap());
|
|
let mut contents = Vec::new();
|
|
File::open(path)
|
|
.unwrap_or_else(|err| args_fail(&format!("Couldn't open {}: {}", filename, err)))
|
|
.read_to_end(&mut contents)
|
|
.unwrap_or_else(|err| args_fail(&format!("Couldn't read {}: {}", filename, err)));
|
|
(contents, url)
|
|
})
|
|
.collect();
|
|
|
|
let is_printing_version = opt_match.opt_present("v") || opt_match.opt_present("version");
|
|
|
|
let legacy_layout = opt_match.opt_present("legacy-layout");
|
|
if legacy_layout {
|
|
set_pref!(layout.legacy_layout, true);
|
|
set_pref!(layout.flexbox.enabled, true);
|
|
}
|
|
|
|
let opts = Opts {
|
|
debug: debug_options.clone(),
|
|
legacy_layout,
|
|
tile_size,
|
|
time_profiling,
|
|
time_profiler_trace_path: opt_match.opt_str("profiler-trace-path"),
|
|
mem_profiler_period,
|
|
nonincremental_layout,
|
|
userscripts: opt_match.opt_default("userscripts", ""),
|
|
user_stylesheets,
|
|
output_file: opt_match.opt_str("o"),
|
|
headless: opt_match.opt_present("z"),
|
|
hard_fail: opt_match.opt_present("f") && !opt_match.opt_present("F"),
|
|
devtools_port,
|
|
devtools_server_enabled,
|
|
webdriver_port,
|
|
initial_window_size,
|
|
multiprocess: opt_match.opt_present("M"),
|
|
background_hang_monitor: opt_match.opt_present("B"),
|
|
sandbox: opt_match.opt_present("S"),
|
|
random_pipeline_closure_probability,
|
|
random_pipeline_closure_seed,
|
|
exit_after_load: opt_match.opt_present("x"),
|
|
config_dir: opt_match.opt_str("config-dir").map(Into::into),
|
|
is_printing_version,
|
|
shaders_dir: opt_match.opt_str("shaders").map(Into::into),
|
|
certificate_path: opt_match.opt_str("certificate-path"),
|
|
ignore_certificate_errors: opt_match.opt_present("ignore-certificate-errors"),
|
|
unminify_js: opt_match.opt_present("unminify-js"),
|
|
local_script_source: opt_match.opt_str("local-script-source"),
|
|
print_pwm: opt_match.opt_present("print-pwm"),
|
|
minibrowser: !opt_match.opt_present("no-minibrowser"),
|
|
};
|
|
|
|
set_options(opts);
|
|
|
|
if let Some(layout_threads) = layout_threads {
|
|
set_pref!(layout.threads, layout_threads as i64);
|
|
}
|
|
|
|
ArgumentParsingResult::ChromeProcess(opt_match)
|
|
}
|
|
|
|
pub enum ArgumentParsingResult {
|
|
ChromeProcess(Matches),
|
|
ContentProcess(Matches, String),
|
|
}
|
|
|
|
// Make Opts available globally. This saves having to clone and pass
|
|
// opts everywhere it is used, which gets particularly cumbersome
|
|
// when passing through the DOM structures.
|
|
lazy_static! {
|
|
static ref OPTIONS: RwLock<Opts> = RwLock::new(default_opts());
|
|
}
|
|
|
|
pub fn set_options(opts: Opts) {
|
|
MULTIPROCESS.store(opts.multiprocess, Ordering::SeqCst);
|
|
*OPTIONS.write().unwrap() = opts;
|
|
}
|
|
|
|
#[inline]
|
|
pub fn get() -> RwLockReadGuard<'static, Opts> {
|
|
OPTIONS.read().unwrap()
|
|
}
|