Stylo

This repo contains Servo’s downstream fork of Stylo.

The branches are as follows:

• upstream has upstream mozilla-central filtered to the paths we care about (style.paths), but is otherwise unmodified
• main has our downstream patches, plus the scripts and workflows for syncing with mozilla-central, to be rebased onto upstream

Building Servo against your local Stylo

Assuming your local servo and stylo directories are siblings, you can build servo against stylo by adding the following to servo/Cargo.toml:

[patch."https://github.com/servo/stylo"]
selectors = { path = "../stylo/selectors" }
servo_arc = { path = "../stylo/servo_arc" }
stylo_atoms = { path = "../stylo/stylo_atoms" }
style = { path = "../stylo/style" }
stylo_config = { path = "../stylo/stylo_config" }
stylo_dom = { path = "../stylo/stylo_dom" }
style_malloc_size_of = { path = "../stylo/malloc_size_of", package = "malloc_size_of" }
style_traits = { path = "../stylo/style_traits" }

Syncing upstream with mozilla-central

Start by generating a filtered copy of mozilla-central. This will cache the raw mozilla-central in _cache/upstream, storing the result in _filtered:

$ ./sync.sh _filtered

If _filtered already exists, you will need to delete it and try again:

$ rm -Rf _filtered

Now overwrite our upstream with those commits and push:

$ git fetch -f --progress ./_filtered master:upstream
$ git push -fu --progress origin upstream

Rebasing main onto upstream

Start by fetching upstream into your local repo:

$ git fetch -f origin upstream:upstream

In general, the filtering process is deterministic, yielding the same commit hashes each time, so we can rebase normally:

$ git rebase upstream

But if the filtering config changes or Mozilla moves to GitHub, the commit hashes on upstream may change. In this case, we need to tell git where the old upstream ends and our own commits start (notice the ~):

$ git log --pretty=\%H --grep='Servo initial downstream commit'
e62d7f0090941496e392e1dc91df103a38e3f488

$ git rebase --onto upstream e62d7f0090941496e392e1dc91df103a38e3f488~
Successfully rebased and updated refs/heads/main.

start-rebase.sh takes care of this automatically, but you should still use git rebase for subsequent steps like --continue and --abort:

$ ./start-rebase.sh upstream
$ ./start-rebase.sh upstream -i     # interactive
$ git rebase --continue             # not ./start-rebase.sh --continue
$ git rebase --abort                # not ./start-rebase.sh --abort

Or if we aren’t ready to rebase onto the tip of upstream:

$ ./start-rebase.sh upstream~10 -i

lib.rs:

Fork of Arc for Servo. This has the following advantages over std::sync::Arc:

• We don't waste storage on the weak reference count.
• We don't do extra RMU operations to handle the possibility of weak references.
• We can experiment with arena allocation (todo).
• We can add methods to support our custom use cases 1.
• We have support for dynamically-sized types (see from_header_and_iter).
• We have support for thin arcs to unsized types (see ThinArc).
• We have support for references to static data, which don't do any refcounting.