[ { "path": ".github/workflows/main.yml", "content": "name: CI\n\non:\n push:\n branches: [\"main\"]\n pull_request:\n workflow_dispatch:\n merge_group:\n types: [checks_requested]\n\n\njobs:\n linux-debug:\n name: Linux (Debug)\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v4\n - name: Install Rust\n uses: dtolnay/rust-toolchain@stable\n - name: Run Tests\n run: cargo build --features servo\n env:\n RUST_BACKTRACE: 1\n\n linux-release:\n name: Linux (Release)\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v4\n - name: Install Rust\n uses: dtolnay/rust-toolchain@stable\n - name: Run Tests\n run: cargo build --release --features servo\n env:\n RUST_BACKTRACE: 1\n\n macos-debug:\n name: macOS (Debug)\n runs-on: macos-latest\n steps:\n - uses: actions/checkout@v4\n - name: Install Rust\n uses: dtolnay/rust-toolchain@stable\n - name: Run Tests\n run: cargo build --features servo\n env:\n RUST_BACKTRACE: 1\n\n windows-debug:\n name: Windows (Debug)\n runs-on: windows-latest\n steps:\n - uses: actions/checkout@v4\n - name: Install Rust\n uses: dtolnay/rust-toolchain@stable\n - name: Run Tests\n run: cargo build --features servo\n env:\n RUST_BACKTRACE: 1\n\n build-result:\n name: Result\n runs-on: ubuntu-latest\n if: ${{ always() }}\n needs:\n - linux-debug\n - linux-release\n - macos-debug\n - windows-debug\n steps:\n - name: Success\n if: ${{ !contains(needs.*.result, 'failure') && !contains(needs.*.result, 'cancelled') }}\n run: exit 0\n - name: Failure\n if: ${{ contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled') }}\n run: exit 1\n\n" }, { "path": ".github/workflows/mirror-to-release-branch.yml", "content": "name: 🪞 Mirror `main`\non:\n push:\n branches:\n - main\n\njobs:\n mirror:\n name: Mirror\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v4\n with:\n fetch-depth: 0\n - name: Get branch name\n id: branch-name\n run: |\n first_commit=$(git log --pretty=\\%H --grep='Servo initial downstream commit')\n upstream_base=\"$first_commit~\"\n echo BRANCH_NAME=$(git log -n1 --pretty='%as' $upstream_base) >> $GITHUB_OUTPUT\n - uses: google/mirror-branch-action@v1.0\n name: Mirror to ${{ steps.branch-name.outputs.BRANCH_NAME }}\n with:\n github-token: ${{ secrets.GITHUB_TOKEN }}\n source: main\n dest: ${{ steps.branch-name.outputs.BRANCH_NAME }}\n" }, { "path": ".github/workflows/sync-upstream.yml", "content": "name: Sync upstream with mozilla-central\n\non:\n schedule:\n - cron: '0 13 * * *'\n workflow_dispatch:\n\njobs:\n sync:\n name: Sync\n runs-on: ubuntu-22.04\n steps:\n - uses: actions/checkout@v3\n with:\n fetch-depth: 1\n - uses: actions/cache@v3\n with:\n path: _cache/upstream\n key: upstream\n - run: |\n ./sync.sh _filtered\n git fetch -f --progress ./_filtered main:upstream\n git push -fu --progress origin upstream\n" }, { "path": ".gitignore", "content": "/_cache/\n/_filtered/\n/target/\n/style/properties/__pycache__/\nCargo.lock\n" }, { "path": "Cargo.toml", "content": "[workspace]\nresolver = \"2\"\nmembers = [\n \"stylo_atoms\",\n \"stylo_dom\",\n \"malloc_size_of\",\n \"rustfmt.toml\",\n \"selectors\",\n \"servo_arc\",\n \"style\",\n \"style_derive\",\n \"stylo_static_prefs\",\n \"style_traits\",\n \"to_shmem\",\n \"to_shmem_derive\",\n]\ndefault-members = [\"style\"]\n\n[workspace.package]\nversion = \"0.17.0\"\n\n[workspace.dependencies]\n# in-repo dependencies (separately versioned)\nservo_arc = { version = \"0.4.3\", path = \"./servo_arc\" }\nselectors = { version = \"0.38.0\", path = \"./selectors\" }\nto_shmem = { version = \"0.4.0\", path = \"./to_shmem\", features = [\"servo\"] }\nto_shmem_derive = { version = \"0.1.0\", path = \"./to_shmem_derive\" }\n\n# in-repo dependencies (main version)\nmalloc_size_of = { version = \"0.17.0\", path = \"./malloc_size_of\", package = \"stylo_malloc_size_of\", features = [\"servo\"] }\nstatic_prefs = { version = \"0.17.0\", path = \"./stylo_static_prefs\", package = \"stylo_static_prefs\" }\nstylo_atoms = { version = \"0.17.0\", path = \"./stylo_atoms\" }\ndom = { version = \"0.17.0\", path = \"./stylo_dom\", package = \"stylo_dom\" }\nstyle_traits = { version = \"0.17.0\", path = \"./style_traits\", features = [\"servo\"], package = \"stylo_traits\"}\nstyle_derive = { version = \"0.17.0\", path = \"./style_derive\", package = \"stylo_derive\"}\nstylo = { version = \"0.17.0\", path = \"./style\" }\n" }, { "path": "README.md", "content": "Stylo\n=====\n\n**High-Performance CSS Style Engine**\n\n[![Build Status](https://github.com/servo/stylo/actions/workflows/main.yml/badge.svg)](https://github.com/servo/stylo/actions)\n[![Crates.io](https://img.shields.io/crates/v/stylo.svg)](https://crates.io/crates/stylo)\n[![Docs](https://docs.rs/stylo/badge.svg)](https://docs.rs/stylo)\n![Crates.io License](https://img.shields.io/crates/l/stylo)\n\nStylo is a high-performance, browser-grade CSS style engine written in Rust that powers [Servo](https://servo.org) and [Firefox](https://firefox.com). This repo contains Servo’s downstream version of Stylo. The upstream version lives in mozilla-central with the rest of the Gecko/Firefox codebase.\n\nCoordination of Stylo development happens:\n\n- Here in Github Issues\n- In the [#stylo](https://servo.zulipchat.com/#narrow/channel/417109-stylo) channel of the [Servo Zulip](https://servo.zulipchat.com/)\n- In the [#layout](https://chat.mozilla.org/#/room/#layout:mozilla.org) room of the Mozilla Matrix instance (matrix.mozilla.org)\n\n## High-Level Documentation\n\n- This [Mozilla Hacks article](https://hacks.mozilla.org/2017/08/inside-a-super-fast-css-engine-quantum-css-aka-stylo) contains a high-level overview of the Stylo architecture.\n- There is a [chapter](https://book.servo.org/architecture/style.html) in the Servo Book (although it is a little out of date).\n\n## Branches\n\nThe branches are as follows:\n\n- [**upstream**](https://github.com/servo/style/tree/upstream) has upstream [mozilla-central](https://searchfox.org/mozilla-central/source/servo) filtered to the paths we care about ([style.paths](style.paths)), but is otherwise unmodified.\n- [**main**](https://github.com/servo/style/tree/ci) adds our downstream patches, plus the scripts and workflows for syncing with mozilla-central on top of **upstream**.\n\n> [!WARNING]\n> This repo syncs from upstream by creating a new branch and then rebasing our changes on top of it. This means that `git pull` will not work across syncs (you will need to use `git fetch`, `git reset` and `git rebase`).\n\nMore information on the syncing process is available in [SYNCING.md](SYNCING.md)\n\n## Crates\n\nA guide to the crates contained within this repo\n\n### Stylo Crates\n\nThese crates are largely implementation details of Stylo, although you may need to use some of them directly if you use Stylo.\n\n| Directory | Crate | Notes |\n| --- | --- | --- |\n| style | [![Crates.io](https://img.shields.io/crates/v/stylo.svg)](https://crates.io/crates/stylo) | The main Stylo crate containing the entire CSS engine |\n| style_traits | [![Crates.io](https://img.shields.io/crates/v/stylo_traits.svg)](https://crates.io/crates/stylo_traits) | Types and traits which allow other code to interoperate with Stylo without depending on the main crate directly. |\n| stylo_dom | [![Crates.io](https://img.shields.io/crates/v/stylo_dom.svg)](https://crates.io/crates/stylo_dom) | Similar to stylo_traits (but much smaller) |\n| stylo_atoms | [![Crates.io](https://img.shields.io/crates/v/stylo_atoms.svg)](https://crates.io/crates/stylo_atoms) | [Atoms](https://docs.rs/string_cache/latest/string_cache/struct.Atom.html) for CSS and HTML event related strings |\n| stylo_static_prefs | [![Crates.io](https://img.shields.io/crates/v/stylo_static_prefs.svg)](https://crates.io/crates/stylo_static_prefs) | Configuration for Stylo. Can be used to set runtime preferences (enabling/disabling properties, etc) |\n| style_derive | [![Crates.io](https://img.shields.io/crates/v/stylo_derive.svg)](https://crates.io/crates/stylo_derive) | Internal derive macro for stylo crate |\n\n### Standalone Crates\n\nThese crates form part of Stylo but are also be useful standalone.\n\n| Directory | Crate | Notes |\n| --- | --- | --- |\n| selectors | [![Crates.io](https://img.shields.io/crates/v/selectors.svg)](https://crates.io/crates/selectors) | CSS Selector matching |\n| servo_arc | [![Crates.io](https://img.shields.io/crates/v/servo_arc.svg)](https://crates.io/crates/servo_arc) | A variant on `std::Arc` |\n\nYou may also be interested in the `cssparser` crate which lives in the [servo/rust-cssparser](https://github.com/servo/rust-cssparser) repo.\n\n### Support Crates\n\nLow-level crates which could technically be used standalone but are unlikely to be generally useful in practice.\n\n| Directory | Crate | Notes |\n| --- | --- | --- |\n| malloc_size_of | [![Crates.io](https://img.shields.io/crates/v/stylo_malloc_size_of.svg)](https://crates.io/crates/stylo_malloc_size_of) | Heap size measurement for Stylo values |\n| to_shmem | [![Crates.io](https://img.shields.io/crates/v/to_shmem.svg)](https://crates.io/crates/to_shmem) | Internal utility crate for sharing memory across processes. |\n| to_shmem_derive | [![Crates.io](https://img.shields.io/crates/v/to_shmem_derive.svg)](https://crates.io/crates/to_shmem_derive) | Internal derive macro for to_shmem crate |\n\n## Building Servo Against a Local Copy of Stylo\n\nAssuming your local `servo` and `stylo` directories are siblings, you can build `servo` against `stylo` by adding the following to `servo/Cargo.toml`:\n\n```toml\n[patch.\"https://github.com/servo/stylo\"]\nselectors = { path = \"../stylo/selectors\" }\nservo_arc = { path = \"../stylo/servo_arc\" }\nstylo = { path = \"../stylo/style\" }\nstylo_atoms = { path = \"../stylo/stylo_atoms\" }\nstylo_dom = { path = \"../stylo/stylo_dom\" }\nstylo_malloc_size_of = { path = \"../stylo/malloc_size_of\" }\nstylo_static_prefs = { path = \"../stylo/stylo_static_prefs\" }\nstylo_traits = { path = \"../stylo/style_traits\" }\n```\n\n## Releases\n\nReleases are made every time this repository rebases its changes on top of the latest version of upstream Stylo. There are a lot of crates here. In order to publish them, they must be done in order. One order that works is:\n\n- selectors\n- stylo_static_prefs\n- stylo_atoms\n- stylo_malloc_size_of\n- stylo_dom\n- stylo_derive\n- stylo_traits\n- stylo\n\n## License\n\nStylo is licensed under MPL 2.0\n" }, { "path": "SYNCING.md", "content": "# Syncing\n\nThis file documents the process of syncing this repository with the upstream copy of Stylo in mozilla-central.\n\n## Syncing `upstream` with mozilla-central\n\nStart by generating a filtered copy of mozilla-central. This will cache the raw mozilla-central in `_cache/upstream`, storing the result in `_filtered`:\n\n```sh\n$ ./sync.sh _filtered\n```\n\nIf `_filtered` already exists, you will need to delete it and try again:\n\n```sh\n$ rm -Rf _filtered\n```\n\nNow overwrite our `upstream` with those commits and push:\n\n```sh\n$ git fetch -f --progress ./_filtered main:upstream\n$ git push -fu --progress origin upstream\n```\n\n## Rebasing `main` onto `upstream`\n\nStart by fetching `upstream` into your local repo:\n\n```sh\n$ git fetch -f origin upstream:upstream\n```\n\nIn general, the filtering process is deterministic, yielding the same commit hashes each time, so we can rebase normally:\n\n```sh\n$ git rebase upstream\n```\n\nBut 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 `~`):\n\n```sh\n$ git log --pretty=\\%H --grep='Servo initial downstream commit'\ne62d7f0090941496e392e1dc91df103a38e3f488\n\n$ git rebase --onto upstream e62d7f0090941496e392e1dc91df103a38e3f488~\nSuccessfully rebased and updated refs/heads/main.\n```\n\n`start-rebase.sh` takes care of this automatically, but you should still use `git rebase` for subsequent steps like `--continue` and `--abort`:\n\n```sh\n$ ./start-rebase.sh upstream\n$ ./start-rebase.sh upstream -i # interactive\n$ git rebase --continue # not ./start-rebase.sh --continue\n$ git rebase --abort # not ./start-rebase.sh --abort\n```\n\nOr if we aren’t ready to rebase onto the tip of upstream:\n\n```sh\n$ ./start-rebase.sh upstream~10 -i\n```\n" }, { "path": "commit-from-merge.sh", "content": "#!/bin/sh\n# Usage: commit-from-merge.sh [extra git-commit(1) arguments ...]\n# Given a merge commit made by bors, runs git-commit(1) with your local changes\n# while borrowing the author name/email from the right-hand parent of the merge,\n# and the author date from the committer date of the merge.\nset -eu\n\nlookup_repo=$1; shift\nmerge_commit=$1; shift\nauthor_name_email=$(git -C \"$lookup_repo\" log -n1 --pretty='%aN <%aE>' \"$merge_commit\"\\^2)\ncommitter_date=$(git -C \"$lookup_repo\" log -n1 --pretty='%cd' \"$merge_commit\")\n\nset -- git commit --author=\"$author_name_email\" --date=\"$committer_date\" \"$@\"\necho \"$@\"\n\"$@\"\n" }, { "path": "commit-from-squashed.sh", "content": "#!/bin/sh\n# Usage: commit-from-squashed.sh [extra git-commit(1) arguments ...]\n# Given a squashed commit made by the GitHub merge queue, runs git-commit(1) with your local changes\n# while borrowing our author name/email from that commit, our author date from its committer date,\n# and our commit message from that commit.\nset -eu\n\nsquashed_commit=$1; shift\ncommitter_date=$(git log -n1 --pretty='%cd' \"$squashed_commit\")\n\n# -c is equivalent to --author=$(...'%aN <%aE>') -m $(...'%B'), but allows editing\nset -- git commit -c \"$squashed_commit\" --date=\"$committer_date\" \"$@\"\necho \"$@\"\n\"$@\"\n" }, { "path": "malloc_size_of/Cargo.toml", "content": "[package]\nname = \"stylo_malloc_size_of\"\nversion.workspace = true\nauthors = [\"The Servo Project Developers\"]\nlicense = \"MIT OR Apache-2.0\"\nrepository = \"https://github.com/servo/stylo\"\ndescription = \"An allocator-agnostic crate for measuring the heap size of a value\"\nedition = \"2021\"\n\n[lib]\npath = \"lib.rs\"\n\n[features]\ngecko = [\"thin-vec/gecko-ffi\"]\nservo = [\"string_cache\"]\n\n[dependencies]\napp_units = \"0.7\"\ncssparser = \"0.37\"\neuclid = \"0.22\"\nselectors = { workspace = true }\nservo_arc = { workspace = true }\nsmallbitvec = \"2.3.0\"\nsmallvec = \"1.13\"\nstring_cache = { version = \"0.9\", optional = true }\nthin-vec = { version = \"0.2.13\" }\nvoid = \"1.0.2\"\n" }, { "path": "malloc_size_of/LICENSE-APACHE", "content": " Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\nTERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\nEND OF TERMS AND CONDITIONS\n\nAPPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"[]\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\nCopyright [yyyy] [name of copyright owner]\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n\thttp://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n" }, { "path": "malloc_size_of/LICENSE-MIT", "content": "Permission is hereby granted, free of charge, to any\nperson obtaining a copy of this software and associated\ndocumentation files (the \"Software\"), to deal in the\nSoftware without restriction, including without\nlimitation the rights to use, copy, modify, merge,\npublish, distribute, sublicense, and/or sell copies of\nthe Software, and to permit persons to whom the Software\nis furnished to do so, subject to the following\nconditions:\n\nThe above copyright notice and this permission notice\nshall be included in all copies or substantial portions\nof the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF\nANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED\nTO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A\nPARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT\nSHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\nCLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\nOF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR\nIN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\nDEALINGS IN THE SOFTWARE.\n" }, { "path": "malloc_size_of/lib.rs", "content": "// Copyright 2016-2017 The Servo Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 or the MIT license\n// , at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! A crate for measuring the heap usage of data structures in a way that\n//! integrates with Firefox's memory reporting, particularly the use of\n//! mozjemalloc and DMD. In particular, it has the following features.\n//! - It isn't bound to a particular heap allocator.\n//! - It provides traits for both \"shallow\" and \"deep\" measurement, which gives\n//! flexibility in the cases where the traits can't be used.\n//! - It allows for measuring blocks even when only an interior pointer can be\n//! obtained for heap allocations, e.g. `HashSet` and `HashMap`. (This relies\n//! on the heap allocator having suitable support, which mozjemalloc has.)\n//! - It allows handling of types like `Rc` and `Arc` by providing traits that\n//! are different to the ones for non-graph structures.\n//!\n//! Suggested uses are as follows.\n//! - When possible, use the `MallocSizeOf` trait. (Deriving support is\n//! provided by the `malloc_size_of_derive` crate.)\n//! - If you need an additional synchronization argument, provide a function\n//! that is like the standard trait method, but with the extra argument.\n//! - If you need multiple measurements for a type, provide a function named\n//! `add_size_of` that takes a mutable reference to a struct that contains\n//! the multiple measurement fields.\n//! - When deep measurement (via `MallocSizeOf`) cannot be implemented for a\n//! type, shallow measurement (via `MallocShallowSizeOf`) in combination with\n//! iteration can be a useful substitute.\n//! - `Rc` and `Arc` are always tricky, which is why `MallocSizeOf` is not (and\n//! should not be) implemented for them.\n//! - If an `Rc` or `Arc` is known to be a \"primary\" reference and can always\n//! be measured, it should be measured via the `MallocUnconditionalSizeOf`\n//! trait.\n//! - If an `Rc` or `Arc` should be measured only if it hasn't been seen\n//! before, it should be measured via the `MallocConditionalSizeOf` trait.\n//! - Using universal function call syntax is a good idea when measuring boxed\n//! fields in structs, because it makes it clear that the Box is being\n//! measured as well as the thing it points to. E.g.\n//! ` as MallocSizeOf>::size_of(field, ops)`.\n//!\n//! Note: WebRender has a reduced fork of this crate, so that we can avoid\n//! publishing this crate on crates.io.\n\nuse std::hash::{BuildHasher, Hash};\nuse std::mem::size_of;\nuse std::ops::Range;\nuse std::ops::{Deref, DerefMut};\nuse std::os::raw::c_void;\nuse void::Void;\n\n/// A C function that takes a pointer to a heap allocation and returns its size.\ntype VoidPtrToSizeFn = unsafe extern \"C\" fn(ptr: *const c_void) -> usize;\n\n/// A closure implementing a stateful predicate on pointers.\ntype VoidPtrToBoolFnMut = dyn FnMut(*const c_void) -> bool;\n\n/// Operations used when measuring heap usage of data structures.\npub struct MallocSizeOfOps {\n /// A function that returns the size of a heap allocation.\n size_of_op: VoidPtrToSizeFn,\n\n /// Like `size_of_op`, but can take an interior pointer. Optional because\n /// not all allocators support this operation. If it's not provided, some\n /// memory measurements will actually be computed estimates rather than\n /// real and accurate measurements.\n enclosing_size_of_op: Option,\n\n /// Check if a pointer has been seen before, and remember it for next time.\n /// Useful when measuring `Rc`s and `Arc`s. Optional, because many places\n /// don't need it.\n have_seen_ptr_op: Option>,\n}\n\nimpl MallocSizeOfOps {\n pub fn new(\n size_of: VoidPtrToSizeFn,\n malloc_enclosing_size_of: Option,\n have_seen_ptr: Option>,\n ) -> Self {\n MallocSizeOfOps {\n size_of_op: size_of,\n enclosing_size_of_op: malloc_enclosing_size_of,\n have_seen_ptr_op: have_seen_ptr,\n }\n }\n\n /// Check if an allocation is empty. This relies on knowledge of how Rust\n /// handles empty allocations, which may change in the future.\n fn is_empty(ptr: *const T) -> bool {\n // The correct condition is this:\n // `ptr as usize <= ::std::mem::align_of::()`\n // But we can't call align_of() on a ?Sized T. So we approximate it\n // with the following. 256 is large enough that it should always be\n // larger than the required alignment, but small enough that it is\n // always in the first page of memory and therefore not a legitimate\n // address.\n return ptr as *const usize as usize <= 256;\n }\n\n /// Call `size_of_op` on `ptr`, first checking that the allocation isn't\n /// empty, because some types (such as `Vec`) utilize empty allocations.\n pub unsafe fn malloc_size_of(&self, ptr: *const T) -> usize {\n if MallocSizeOfOps::is_empty(ptr) {\n 0\n } else {\n (self.size_of_op)(ptr as *const c_void)\n }\n }\n\n /// Is an `enclosing_size_of_op` available?\n pub fn has_malloc_enclosing_size_of(&self) -> bool {\n self.enclosing_size_of_op.is_some()\n }\n\n /// Call `enclosing_size_of_op`, which must be available, on `ptr`, which\n /// must not be empty.\n pub unsafe fn malloc_enclosing_size_of(&self, ptr: *const T) -> usize {\n assert!(!MallocSizeOfOps::is_empty(ptr));\n (self.enclosing_size_of_op.unwrap())(ptr as *const c_void)\n }\n\n /// Call `have_seen_ptr_op` on `ptr`.\n pub fn have_seen_ptr(&mut self, ptr: *const T) -> bool {\n let have_seen_ptr_op = self\n .have_seen_ptr_op\n .as_mut()\n .expect(\"missing have_seen_ptr_op\");\n have_seen_ptr_op(ptr as *const c_void)\n }\n}\n\n/// Trait for measuring the \"deep\" heap usage of a data structure. This is the\n/// most commonly-used of the traits.\npub trait MallocSizeOf {\n /// Measure the heap usage of all descendant heap-allocated structures, but\n /// not the space taken up by the value itself.\n fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize;\n}\n\n/// Trait for measuring the \"shallow\" heap usage of a container.\npub trait MallocShallowSizeOf {\n /// Measure the heap usage of immediate heap-allocated descendant\n /// structures, but not the space taken up by the value itself. Anything\n /// beyond the immediate descendants must be measured separately, using\n /// iteration.\n fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize;\n}\n\n/// Like `MallocSizeOf`, but with a different name so it cannot be used\n/// accidentally with derive(MallocSizeOf). For use with types like `Rc` and\n/// `Arc` when appropriate (e.g. when measuring a \"primary\" reference).\npub trait MallocUnconditionalSizeOf {\n /// Measure the heap usage of all heap-allocated descendant structures, but\n /// not the space taken up by the value itself.\n fn unconditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize;\n}\n\n/// `MallocUnconditionalSizeOf` combined with `MallocShallowSizeOf`.\npub trait MallocUnconditionalShallowSizeOf {\n /// `unconditional_size_of` combined with `shallow_size_of`.\n fn unconditional_shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize;\n}\n\n/// Like `MallocSizeOf`, but only measures if the value hasn't already been\n/// measured. For use with types like `Rc` and `Arc` when appropriate (e.g.\n/// when there is no \"primary\" reference).\npub trait MallocConditionalSizeOf {\n /// Measure the heap usage of all heap-allocated descendant structures, but\n /// not the space taken up by the value itself, and only if that heap usage\n /// hasn't already been measured.\n fn conditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize;\n}\n\n/// `MallocConditionalSizeOf` combined with `MallocShallowSizeOf`.\npub trait MallocConditionalShallowSizeOf {\n /// `conditional_size_of` combined with `shallow_size_of`.\n fn conditional_shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize;\n}\n\nimpl MallocSizeOf for String {\n fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n unsafe { ops.malloc_size_of(self.as_ptr()) }\n }\n}\n\nimpl<'a, T: ?Sized> MallocSizeOf for &'a T {\n fn size_of(&self, _ops: &mut MallocSizeOfOps) -> usize {\n // Zero makes sense for a non-owning reference.\n 0\n }\n}\n\nimpl MallocShallowSizeOf for Box {\n fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n unsafe { ops.malloc_size_of(&**self) }\n }\n}\n\nimpl MallocSizeOf for Box {\n fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n self.shallow_size_of(ops) + (**self).size_of(ops)\n }\n}\n\nimpl MallocSizeOf for () {\n fn size_of(&self, _ops: &mut MallocSizeOfOps) -> usize {\n 0\n }\n}\n\nimpl MallocSizeOf for (T1, T2)\nwhere\n T1: MallocSizeOf,\n T2: MallocSizeOf,\n{\n fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n self.0.size_of(ops) + self.1.size_of(ops)\n }\n}\n\nimpl MallocSizeOf for (T1, T2, T3)\nwhere\n T1: MallocSizeOf,\n T2: MallocSizeOf,\n T3: MallocSizeOf,\n{\n fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n self.0.size_of(ops) + self.1.size_of(ops) + self.2.size_of(ops)\n }\n}\n\nimpl MallocSizeOf for (T1, T2, T3, T4)\nwhere\n T1: MallocSizeOf,\n T2: MallocSizeOf,\n T3: MallocSizeOf,\n T4: MallocSizeOf,\n{\n fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n self.0.size_of(ops) + self.1.size_of(ops) + self.2.size_of(ops) + self.3.size_of(ops)\n }\n}\n\nimpl MallocSizeOf for Option {\n fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n if let Some(val) = self.as_ref() {\n val.size_of(ops)\n } else {\n 0\n }\n }\n}\n\nimpl MallocSizeOf for Result {\n fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n match *self {\n Ok(ref x) => x.size_of(ops),\n Err(ref e) => e.size_of(ops),\n }\n }\n}\n\nimpl MallocSizeOf for std::cell::Cell {\n fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n self.get().size_of(ops)\n }\n}\n\nimpl MallocSizeOf for std::cell::RefCell {\n fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n self.borrow().size_of(ops)\n }\n}\n\nimpl<'a, B: ?Sized + ToOwned> MallocSizeOf for std::borrow::Cow<'a, B>\nwhere\n B::Owned: MallocSizeOf,\n{\n fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n match *self {\n std::borrow::Cow::Borrowed(_) => 0,\n std::borrow::Cow::Owned(ref b) => b.size_of(ops),\n }\n }\n}\n\nimpl MallocSizeOf for [T] {\n fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n let mut n = 0;\n for elem in self.iter() {\n n += elem.size_of(ops);\n }\n n\n }\n}\n\nimpl MallocShallowSizeOf for Vec {\n fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n unsafe { ops.malloc_size_of(self.as_ptr()) }\n }\n}\n\nimpl MallocSizeOf for Vec {\n fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n let mut n = self.shallow_size_of(ops);\n for elem in self.iter() {\n n += elem.size_of(ops);\n }\n n\n }\n}\n\nimpl MallocShallowSizeOf for std::collections::VecDeque {\n fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n if ops.has_malloc_enclosing_size_of() {\n if let Some(front) = self.front() {\n // The front element is an interior pointer.\n unsafe { ops.malloc_enclosing_size_of(&*front) }\n } else {\n // This assumes that no memory is allocated when the VecDeque is empty.\n 0\n }\n } else {\n // An estimate.\n self.capacity() * size_of::()\n }\n }\n}\n\nimpl MallocSizeOf for std::collections::VecDeque {\n fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n let mut n = self.shallow_size_of(ops);\n for elem in self.iter() {\n n += elem.size_of(ops);\n }\n n\n }\n}\n\nimpl MallocShallowSizeOf for smallvec::SmallVec {\n fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n if self.spilled() {\n unsafe { ops.malloc_size_of(self.as_ptr()) }\n } else {\n 0\n }\n }\n}\n\nimpl MallocSizeOf for smallvec::SmallVec\nwhere\n A: smallvec::Array,\n A::Item: MallocSizeOf,\n{\n fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n let mut n = self.shallow_size_of(ops);\n for elem in self.iter() {\n n += elem.size_of(ops);\n }\n n\n }\n}\n\nimpl MallocShallowSizeOf for thin_vec::ThinVec {\n fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n if self.capacity() == 0 {\n // If it's the singleton we might not be a heap pointer.\n return 0;\n }\n\n assert_eq!(\n std::mem::size_of::(),\n std::mem::size_of::<*const ()>()\n );\n unsafe { ops.malloc_size_of(*(self as *const Self as *const *const ())) }\n }\n}\n\nimpl MallocSizeOf for thin_vec::ThinVec {\n fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n let mut n = self.shallow_size_of(ops);\n for elem in self.iter() {\n n += elem.size_of(ops);\n }\n n\n }\n}\n\nmacro_rules! malloc_size_of_hash_set {\n ($ty:ty) => {\n impl MallocShallowSizeOf for $ty\n where\n T: Eq + Hash,\n S: BuildHasher,\n {\n fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n if ops.has_malloc_enclosing_size_of() {\n // The first value from the iterator gives us an interior pointer.\n // `ops.malloc_enclosing_size_of()` then gives us the storage size.\n // This assumes that the `HashSet`'s contents (values and hashes)\n // are all stored in a single contiguous heap allocation.\n self.iter()\n .next()\n .map_or(0, |t| unsafe { ops.malloc_enclosing_size_of(t) })\n } else {\n // An estimate.\n self.capacity() * (size_of::() + size_of::())\n }\n }\n }\n\n impl MallocSizeOf for $ty\n where\n T: Eq + Hash + MallocSizeOf,\n S: BuildHasher,\n {\n fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n let mut n = self.shallow_size_of(ops);\n for t in self.iter() {\n n += t.size_of(ops);\n }\n n\n }\n }\n };\n}\n\nmalloc_size_of_hash_set!(std::collections::HashSet);\n\nmacro_rules! malloc_size_of_hash_map {\n ($ty:ty) => {\n impl MallocShallowSizeOf for $ty\n where\n K: Eq + Hash,\n S: BuildHasher,\n {\n fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n // See the implementation for std::collections::HashSet for details.\n if ops.has_malloc_enclosing_size_of() {\n self.values()\n .next()\n .map_or(0, |v| unsafe { ops.malloc_enclosing_size_of(v) })\n } else {\n self.capacity() * (size_of::() + size_of::() + size_of::())\n }\n }\n }\n\n impl MallocSizeOf for $ty\n where\n K: Eq + Hash + MallocSizeOf,\n V: MallocSizeOf,\n S: BuildHasher,\n {\n fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n let mut n = self.shallow_size_of(ops);\n for (k, v) in self.iter() {\n n += k.size_of(ops);\n n += v.size_of(ops);\n }\n n\n }\n }\n };\n}\n\nmalloc_size_of_hash_map!(std::collections::HashMap);\n\nimpl MallocShallowSizeOf for std::collections::BTreeMap\nwhere\n K: Eq + Hash,\n{\n fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n if ops.has_malloc_enclosing_size_of() {\n self.values()\n .next()\n .map_or(0, |v| unsafe { ops.malloc_enclosing_size_of(v) })\n } else {\n self.len() * (size_of::() + size_of::() + size_of::())\n }\n }\n}\n\nimpl MallocSizeOf for std::collections::BTreeMap\nwhere\n K: Eq + Hash + MallocSizeOf,\n V: MallocSizeOf,\n{\n fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n let mut n = self.shallow_size_of(ops);\n for (k, v) in self.iter() {\n n += k.size_of(ops);\n n += v.size_of(ops);\n }\n n\n }\n}\n\n// PhantomData is always 0.\nimpl MallocSizeOf for std::marker::PhantomData {\n fn size_of(&self, _ops: &mut MallocSizeOfOps) -> usize {\n 0\n }\n}\n\n// XXX: we don't want MallocSizeOf to be defined for Rc and Arc. If negative\n// trait bounds are ever allowed, this code should be uncommented.\n// (We do have a compile-fail test for this:\n// rc_arc_must_not_derive_malloc_size_of.rs)\n//impl !MallocSizeOf for Arc { }\n//impl !MallocShallowSizeOf for Arc { }\n\nimpl MallocUnconditionalShallowSizeOf for servo_arc::Arc {\n fn unconditional_shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n unsafe { ops.malloc_size_of(self.heap_ptr()) }\n }\n}\n\nimpl MallocUnconditionalSizeOf for servo_arc::Arc {\n fn unconditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n self.unconditional_shallow_size_of(ops) + (**self).size_of(ops)\n }\n}\n\nimpl MallocConditionalShallowSizeOf for servo_arc::Arc {\n fn conditional_shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n if ops.have_seen_ptr(self.heap_ptr()) {\n 0\n } else {\n self.unconditional_shallow_size_of(ops)\n }\n }\n}\n\nimpl MallocConditionalSizeOf for servo_arc::Arc {\n fn conditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n if ops.have_seen_ptr(self.heap_ptr()) {\n 0\n } else {\n self.unconditional_size_of(ops)\n }\n }\n}\n\n/// If a mutex is stored directly as a member of a data type that is being measured,\n/// it is the unique owner of its contents and deserves to be measured.\n///\n/// If a mutex is stored inside of an Arc value as a member of a data type that is being measured,\n/// the Arc will not be automatically measured so there is no risk of overcounting the mutex's\n/// contents.\nimpl MallocSizeOf for std::sync::Mutex {\n fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n (*self.lock().unwrap()).size_of(ops)\n }\n}\n\nimpl MallocSizeOf for smallbitvec::SmallBitVec {\n fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n if let Some(ptr) = self.heap_ptr() {\n unsafe { ops.malloc_size_of(ptr) }\n } else {\n 0\n }\n }\n}\n\nimpl MallocSizeOf for euclid::Length {\n fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n self.0.size_of(ops)\n }\n}\n\nimpl MallocSizeOf for euclid::Scale {\n fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n self.0.size_of(ops)\n }\n}\n\nimpl MallocSizeOf for euclid::Point2D {\n fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n self.x.size_of(ops) + self.y.size_of(ops)\n }\n}\n\nimpl MallocSizeOf for euclid::Rect {\n fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n self.origin.size_of(ops) + self.size.size_of(ops)\n }\n}\n\nimpl MallocSizeOf for euclid::SideOffsets2D {\n fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n self.top.size_of(ops)\n + self.right.size_of(ops)\n + self.bottom.size_of(ops)\n + self.left.size_of(ops)\n }\n}\n\nimpl MallocSizeOf for euclid::Size2D {\n fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n self.width.size_of(ops) + self.height.size_of(ops)\n }\n}\n\nimpl MallocSizeOf for euclid::Transform2D {\n fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n self.m11.size_of(ops)\n + self.m12.size_of(ops)\n + self.m21.size_of(ops)\n + self.m22.size_of(ops)\n + self.m31.size_of(ops)\n + self.m32.size_of(ops)\n }\n}\n\nimpl MallocSizeOf for euclid::Transform3D {\n fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n self.m11.size_of(ops)\n + self.m12.size_of(ops)\n + self.m13.size_of(ops)\n + self.m14.size_of(ops)\n + self.m21.size_of(ops)\n + self.m22.size_of(ops)\n + self.m23.size_of(ops)\n + self.m24.size_of(ops)\n + self.m31.size_of(ops)\n + self.m32.size_of(ops)\n + self.m33.size_of(ops)\n + self.m34.size_of(ops)\n + self.m41.size_of(ops)\n + self.m42.size_of(ops)\n + self.m43.size_of(ops)\n + self.m44.size_of(ops)\n }\n}\n\nimpl MallocSizeOf for euclid::Vector2D {\n fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n self.x.size_of(ops) + self.y.size_of(ops)\n }\n}\n\nimpl MallocSizeOf for selectors::parser::AncestorHashes {\n fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n let selectors::parser::AncestorHashes { ref packed_hashes } = *self;\n packed_hashes.size_of(ops)\n }\n}\n\nimpl MallocUnconditionalSizeOf\n for selectors::parser::Selector\nwhere\n Impl::NonTSPseudoClass: MallocSizeOf,\n Impl::PseudoElement: MallocSizeOf,\n{\n fn unconditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n let mut n = 0;\n\n // It's OK to measure this ThinArc directly because it's the\n // \"primary\" reference. (The secondary references are on the\n // Stylist.)\n n += unsafe { ops.malloc_size_of(self.thin_arc_heap_ptr()) };\n for component in self.iter_raw_match_order() {\n n += component.size_of(ops);\n }\n\n n\n }\n}\n\nimpl MallocUnconditionalSizeOf\n for selectors::parser::SelectorList\nwhere\n Impl::NonTSPseudoClass: MallocSizeOf,\n Impl::PseudoElement: MallocSizeOf,\n{\n fn unconditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n let mut n = 0;\n\n // It's OK to measure this ThinArc directly because it's the \"primary\" reference. (The\n // secondary references are on the Stylist.)\n n += unsafe { ops.malloc_size_of(self.thin_arc_heap_ptr()) };\n if self.len() > 1 {\n for selector in self.slice().iter() {\n n += selector.size_of(ops);\n }\n }\n n\n }\n}\n\nimpl MallocUnconditionalSizeOf\n for selectors::parser::Component\nwhere\n Impl::NonTSPseudoClass: MallocSizeOf,\n Impl::PseudoElement: MallocSizeOf,\n{\n fn unconditional_size_of(&self, ops: &mut MallocSizeOfOps) -> usize {\n use selectors::parser::Component;\n\n match self {\n Component::AttributeOther(ref attr_selector) => attr_selector.size_of(ops),\n Component::Negation(ref components) => components.unconditional_size_of(ops),\n Component::NonTSPseudoClass(ref pseudo) => (*pseudo).size_of(ops),\n Component::Slotted(ref selector) | Component::Host(Some(ref selector)) => {\n selector.unconditional_size_of(ops)\n },\n Component::Is(ref list) | Component::Where(ref list) => list.unconditional_size_of(ops),\n Component::Has(ref relative_selectors) => relative_selectors.size_of(ops),\n Component::NthOf(ref nth_of_data) => nth_of_data.size_of(ops),\n Component::PseudoElement(ref pseudo) => (*pseudo).size_of(ops),\n Component::Combinator(..)\n | Component::ExplicitAnyNamespace\n | Component::ExplicitNoNamespace\n | Component::DefaultNamespace(..)\n | Component::Namespace(..)\n | Component::ExplicitUniversalType\n | Component::LocalName(..)\n | Component::ID(..)\n | Component::Part(..)\n | Component::Class(..)\n | Component::AttributeInNoNamespaceExists { .. }\n | Component::AttributeInNoNamespace { .. }\n | Component::Root\n | Component::Empty\n | Component::Scope\n | Component::ImplicitScope\n | Component::ParentSelector\n | Component::Nth(..)\n | Component::Host(None)\n | Component::RelativeSelectorAnchor\n | Component::Invalid(..) => 0,\n }\n }\n}\n\nimpl MallocSizeOf\n for selectors::attr::AttrSelectorWithOptionalNamespace\n{\n fn size_of(&self, _ops: &mut MallocSizeOfOps) -> usize {\n 0\n }\n}\n\nimpl MallocSizeOf for selectors::parser::AnPlusB {\n fn size_of(&self, _ops: &mut MallocSizeOfOps) -> usize {\n 0\n }\n}\n\nimpl MallocSizeOf for Void {\n #[inline]\n fn size_of(&self, _ops: &mut MallocSizeOfOps) -> usize {\n void::unreachable(*self)\n }\n}\n\n#[cfg(feature = \"servo\")]\nimpl MallocSizeOf for string_cache::Atom {\n fn size_of(&self, _ops: &mut MallocSizeOfOps) -> usize {\n 0\n }\n}\n\n/// For use on types where size_of() returns 0.\n#[macro_export]\nmacro_rules! malloc_size_of_is_0(\n ($($ty:ty),+) => (\n $(\n impl $crate::MallocSizeOf for $ty {\n #[inline(always)]\n fn size_of(&self, _: &mut $crate::MallocSizeOfOps) -> usize {\n 0\n }\n }\n )+\n );\n ($($ty:ident<$($gen:ident),+>),+) => (\n $(\n impl<$($gen: $crate::MallocSizeOf),+> $crate::MallocSizeOf for $ty<$($gen),+> {\n #[inline(always)]\n fn size_of(&self, _: &mut $crate::MallocSizeOfOps) -> usize {\n 0\n }\n }\n )+\n );\n);\n\nmalloc_size_of_is_0!(bool, char, str);\nmalloc_size_of_is_0!(u8, u16, u32, u64, u128, usize);\nmalloc_size_of_is_0!(i8, i16, i32, i64, i128, isize);\nmalloc_size_of_is_0!(f32, f64);\n\nmalloc_size_of_is_0!(std::sync::atomic::AtomicBool);\nmalloc_size_of_is_0!(std::sync::atomic::AtomicIsize);\nmalloc_size_of_is_0!(std::sync::atomic::AtomicU32);\nmalloc_size_of_is_0!(std::sync::atomic::AtomicUsize);\nmalloc_size_of_is_0!(std::num::NonZeroUsize);\nmalloc_size_of_is_0!(std::num::NonZeroU64);\n\nmalloc_size_of_is_0!(Range, Range, Range, Range, Range);\nmalloc_size_of_is_0!(Range, Range, Range, Range, Range);\nmalloc_size_of_is_0!(Range, Range);\n\nmalloc_size_of_is_0!(app_units::Au);\n\nmalloc_size_of_is_0!(\n cssparser::TokenSerializationType,\n cssparser::SourceLocation,\n cssparser::SourcePosition,\n cssparser::UnicodeRange\n);\n\nmalloc_size_of_is_0!(selectors::OpaqueElement);\n\n/// Measurable that defers to inner value and used to verify MallocSizeOf implementation in a\n/// struct.\n#[derive(Clone)]\npub struct Measurable(pub T);\n\nimpl Deref for Measurable {\n type Target = T;\n\n fn deref(&self) -> &T {\n &self.0\n }\n}\n\nimpl DerefMut for Measurable {\n fn deref_mut(&mut self) -> &mut T {\n &mut self.0\n }\n}\n" }, { "path": "rustfmt.toml", "content": "match_block_trailing_comma = true\nreorder_imports = true\n" }, { "path": "selectors/CHANGES.md", "content": "- `parser.rs` no longer wraps values in quotes (`\"...\"`) but expects their `to_css` impl to already wrap it ([Gecko Bug 1854809](https://bugzilla.mozilla.org/show_bug.cgi?id=1854809))\n" }, { "path": "selectors/Cargo.toml", "content": "[package]\nname = \"selectors\"\nversion = \"0.38.0\"\nauthors = [\"The Servo Project Developers\"]\ndocumentation = \"https://docs.rs/selectors/\"\ndescription = \"CSS Selectors matching for Rust\"\nrepository = \"https://github.com/servo/stylo\"\nreadme = \"README.md\"\nkeywords = [\"css\", \"selectors\"]\nlicense = \"MPL-2.0\"\nedition = \"2021\"\nbuild = \"build.rs\"\n\n[lib]\nname = \"selectors\"\npath = \"lib.rs\"\n\n[features]\nbench = []\nto_shmem = [\"dep:to_shmem\", \"dep:to_shmem_derive\"]\n\n[dependencies]\nbitflags = \"2\"\ncssparser = \"0.37\"\nderive_more = { version = \"2\", features = [\"add\", \"add_assign\"] }\nrustc-hash = \"2.1.1\"\nlog = \"0.4\"\nphf = \"0.13\"\nprecomputed-hash = \"0.1\"\nservo_arc = { workspace = true }\nsmallvec = \"1.0\"\nto_shmem = { workspace = true, optional = true }\nto_shmem_derive = { workspace = true, optional = true }\nnew_debug_unreachable = \"1\"\n\n[build-dependencies]\nphf_codegen = \"0.13\"\n" }, { "path": "selectors/README.md", "content": "rust-selectors\n==============\n\n* [![Build Status](https://github.com/servo/stylo/actions/workflows/main.yml/badge.svg)](https://github.com/servo/stylo/actions)\n* [Documentation](https://docs.rs/selectors)\n* [crates.io](https://crates.io/crates/selectors)\n\nCSS Selectors library for Rust.\nIncludes parsing and serilization of selectors,\nas well as matching against a generic tree of elements.\nPseudo-elements and most pseudo-classes are generic as well.\n\n**Warning:** breaking changes are made to this library fairly frequently\n(13 times in 2016, for example).\nHowever you can use this crate without updating it that often,\nold versions stay available on crates.io and Cargo will only automatically update\nto versions that are numbered as compatible.\n\nTo see how to use this library with your own tree representation,\nsee [Kuchiki’s `src/select.rs`](https://github.com/kuchiki-rs/kuchiki/blob/master/src/select.rs).\n(Note however that Kuchiki is not always up to date with the latest rust-selectors version,\nso that code may need to be tweaked.)\nIf you don’t already have a tree data structure,\nconsider using [Kuchiki](https://github.com/kuchiki-rs/kuchiki) itself.\n" }, { "path": "selectors/attr.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\nuse crate::parser::SelectorImpl;\nuse cssparser::ToCss;\nuse std::fmt;\n\n#[cfg(feature = \"to_shmem\")]\nuse to_shmem_derive::ToShmem;\n\n#[derive(Clone, Eq, PartialEq)]\n#[cfg_attr(feature = \"to_shmem\", derive(ToShmem))]\n#[cfg_attr(feature = \"to_shmem\", shmem(no_bounds))]\npub struct AttrSelectorWithOptionalNamespace {\n #[cfg_attr(feature = \"to_shmem\", shmem(field_bound))]\n pub namespace: Option>,\n #[cfg_attr(feature = \"to_shmem\", shmem(field_bound))]\n pub local_name: Impl::LocalName,\n pub local_name_lower: Impl::LocalName,\n #[cfg_attr(feature = \"to_shmem\", shmem(field_bound))]\n pub operation: ParsedAttrSelectorOperation,\n}\n\nimpl AttrSelectorWithOptionalNamespace {\n pub fn namespace(&self) -> Option> {\n self.namespace.as_ref().map(|ns| match ns {\n NamespaceConstraint::Any => NamespaceConstraint::Any,\n NamespaceConstraint::Specific((_, ref url)) => NamespaceConstraint::Specific(url),\n })\n }\n}\n\n#[derive(Clone, Eq, PartialEq)]\n#[cfg_attr(feature = \"to_shmem\", derive(ToShmem))]\npub enum NamespaceConstraint {\n Any,\n\n /// Empty string for no namespace\n Specific(NamespaceUrl),\n}\n\n#[derive(Clone, Eq, PartialEq)]\n#[cfg_attr(feature = \"to_shmem\", derive(ToShmem))]\npub enum ParsedAttrSelectorOperation {\n Exists,\n WithValue {\n operator: AttrSelectorOperator,\n case_sensitivity: ParsedCaseSensitivity,\n value: AttrValue,\n },\n}\n\n#[derive(Clone, Eq, PartialEq)]\npub enum AttrSelectorOperation {\n Exists,\n WithValue {\n operator: AttrSelectorOperator,\n case_sensitivity: CaseSensitivity,\n value: AttrValue,\n },\n}\n\nimpl AttrSelectorOperation {\n pub fn eval_str(&self, element_attr_value: &str) -> bool\n where\n AttrValue: AsRef,\n {\n match *self {\n AttrSelectorOperation::Exists => true,\n AttrSelectorOperation::WithValue {\n operator,\n case_sensitivity,\n ref value,\n } => operator.eval_str(element_attr_value, value.as_ref(), case_sensitivity),\n }\n }\n}\n\n#[derive(Clone, Copy, Eq, PartialEq)]\n#[cfg_attr(feature = \"to_shmem\", derive(ToShmem))]\npub enum AttrSelectorOperator {\n Equal,\n Includes,\n DashMatch,\n Prefix,\n Substring,\n Suffix,\n}\n\nimpl ToCss for AttrSelectorOperator {\n fn to_css(&self, dest: &mut W) -> fmt::Result\n where\n W: fmt::Write,\n {\n // https://drafts.csswg.org/cssom/#serializing-selectors\n // See \"attribute selector\".\n dest.write_str(match *self {\n AttrSelectorOperator::Equal => \"=\",\n AttrSelectorOperator::Includes => \"~=\",\n AttrSelectorOperator::DashMatch => \"|=\",\n AttrSelectorOperator::Prefix => \"^=\",\n AttrSelectorOperator::Substring => \"*=\",\n AttrSelectorOperator::Suffix => \"$=\",\n })\n }\n}\n\nimpl AttrSelectorOperator {\n pub fn eval_str(\n self,\n element_attr_value: &str,\n attr_selector_value: &str,\n case_sensitivity: CaseSensitivity,\n ) -> bool {\n let e = element_attr_value.as_bytes();\n let s = attr_selector_value.as_bytes();\n let case = case_sensitivity;\n match self {\n AttrSelectorOperator::Equal => case.eq(e, s),\n AttrSelectorOperator::Prefix => {\n !s.is_empty() && e.len() >= s.len() && case.eq(&e[..s.len()], s)\n },\n AttrSelectorOperator::Suffix => {\n !s.is_empty() && e.len() >= s.len() && case.eq(&e[(e.len() - s.len())..], s)\n },\n AttrSelectorOperator::Substring => {\n !s.is_empty() && case.contains(element_attr_value, attr_selector_value)\n },\n AttrSelectorOperator::Includes => {\n !s.is_empty()\n && element_attr_value\n .split(SELECTOR_WHITESPACE)\n .any(|part| case.eq(part.as_bytes(), s))\n },\n AttrSelectorOperator::DashMatch => {\n case.eq(e, s) || (e.get(s.len()) == Some(&b'-') && case.eq(&e[..s.len()], s))\n },\n }\n }\n}\n\n/// The definition of whitespace per CSS Selectors Level 3 § 4.\npub static SELECTOR_WHITESPACE: &[char] = &[' ', '\\t', '\\n', '\\r', '\\x0C'];\n\n#[derive(Clone, Copy, Debug, Eq, PartialEq)]\n#[cfg_attr(feature = \"to_shmem\", derive(ToShmem))]\npub enum ParsedCaseSensitivity {\n /// 's' was specified.\n ExplicitCaseSensitive,\n /// 'i' was specified.\n AsciiCaseInsensitive,\n /// No flags were specified and HTML says this is a case-sensitive attribute.\n CaseSensitive,\n /// No flags were specified and HTML says this is a case-insensitive attribute.\n AsciiCaseInsensitiveIfInHtmlElementInHtmlDocument,\n}\n\n#[derive(Clone, Copy, Debug, Eq, PartialEq)]\npub enum CaseSensitivity {\n CaseSensitive,\n AsciiCaseInsensitive,\n}\n\nimpl CaseSensitivity {\n pub fn eq(self, a: &[u8], b: &[u8]) -> bool {\n match self {\n CaseSensitivity::CaseSensitive => a == b,\n CaseSensitivity::AsciiCaseInsensitive => a.eq_ignore_ascii_case(b),\n }\n }\n\n pub fn contains(self, haystack: &str, needle: &str) -> bool {\n match self {\n CaseSensitivity::CaseSensitive => haystack.contains(needle),\n CaseSensitivity::AsciiCaseInsensitive => {\n if let Some((&n_first_byte, n_rest)) = needle.as_bytes().split_first() {\n haystack.bytes().enumerate().any(|(i, byte)| {\n if !byte.eq_ignore_ascii_case(&n_first_byte) {\n return false;\n }\n let after_this_byte = &haystack.as_bytes()[i + 1..];\n match after_this_byte.get(..n_rest.len()) {\n None => false,\n Some(haystack_slice) => haystack_slice.eq_ignore_ascii_case(n_rest),\n }\n })\n } else {\n // any_str.contains(\"\") == true,\n // though these cases should be handled with *NeverMatches and never go here.\n true\n }\n },\n }\n }\n}\n" }, { "path": "selectors/bloom.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! Counting and non-counting Bloom filters tuned for use as ancestor filters\n//! for selector matching.\n\nuse std::fmt::{self, Debug};\n\n// The top 8 bits of the 32-bit hash value are not used by the bloom filter.\n// Consumers may rely on this to pack hashes more efficiently.\npub const BLOOM_HASH_MASK: u32 = 0x00ffffff;\nconst KEY_SIZE: usize = 12;\n\nconst ARRAY_SIZE: usize = 1 << KEY_SIZE;\nconst KEY_MASK: u32 = (1 << KEY_SIZE) - 1;\n\n/// A counting Bloom filter with 8-bit counters.\npub type BloomFilter = CountingBloomFilter;\n\n/// A counting Bloom filter with parameterized storage to handle\n/// counters of different sizes. For now we assume that having two hash\n/// functions is enough, but we may revisit that decision later.\n///\n/// The filter uses an array with 2**KeySize entries.\n///\n/// Assuming a well-distributed hash function, a Bloom filter with\n/// array size M containing N elements and\n/// using k hash function has expected false positive rate exactly\n///\n/// $ (1 - (1 - 1/M)^{kN})^k $\n///\n/// because each array slot has a\n///\n/// $ (1 - 1/M)^{kN} $\n///\n/// chance of being 0, and the expected false positive rate is the\n/// probability that all of the k hash functions will hit a nonzero\n/// slot.\n///\n/// For reasonable assumptions (M large, kN large, which should both\n/// hold if we're worried about false positives) about M and kN this\n/// becomes approximately\n///\n/// $$ (1 - \\exp(-kN/M))^k $$\n///\n/// For our special case of k == 2, that's $(1 - \\exp(-2N/M))^2$,\n/// or in other words\n///\n/// $$ N/M = -0.5 * \\ln(1 - \\sqrt(r)) $$\n///\n/// where r is the false positive rate. This can be used to compute\n/// the desired KeySize for a given load N and false positive rate r.\n///\n/// If N/M is assumed small, then the false positive rate can\n/// further be approximated as 4*N^2/M^2. So increasing KeySize by\n/// 1, which doubles M, reduces the false positive rate by about a\n/// factor of 4, and a false positive rate of 1% corresponds to\n/// about M/N == 20.\n///\n/// What this means in practice is that for a few hundred keys using a\n/// KeySize of 12 gives false positive rates on the order of 0.25-4%.\n///\n/// Similarly, using a KeySize of 10 would lead to a 4% false\n/// positive rate for N == 100 and to quite bad false positive\n/// rates for larger N.\n#[derive(Clone, Default)]\npub struct CountingBloomFilter\nwhere\n S: BloomStorage,\n{\n storage: S,\n}\n\nimpl CountingBloomFilter\nwhere\n S: BloomStorage,\n{\n /// Creates a new bloom filter.\n #[inline]\n pub fn new() -> Self {\n Default::default()\n }\n\n #[inline]\n pub fn clear(&mut self) {\n self.storage = Default::default();\n }\n\n // Slow linear accessor to make sure the bloom filter is zeroed. This should\n // never be used in release builds.\n #[cfg(debug_assertions)]\n pub fn is_zeroed(&self) -> bool {\n self.storage.is_zeroed()\n }\n\n #[cfg(not(debug_assertions))]\n pub fn is_zeroed(&self) -> bool {\n unreachable!()\n }\n\n /// Inserts an item with a particular hash into the bloom filter.\n #[inline]\n pub fn insert_hash(&mut self, hash: u32) {\n self.storage.adjust_first_slot(hash, true);\n self.storage.adjust_second_slot(hash, true);\n }\n\n /// Removes an item with a particular hash from the bloom filter.\n #[inline]\n pub fn remove_hash(&mut self, hash: u32) {\n self.storage.adjust_first_slot(hash, false);\n self.storage.adjust_second_slot(hash, false);\n }\n\n /// Check whether the filter might contain an item with the given hash.\n /// This can sometimes return true even if the item is not in the filter,\n /// but will never return false for items that are actually in the filter.\n #[inline]\n pub fn might_contain_hash(&self, hash: u32) -> bool {\n !self.storage.first_slot_is_empty(hash) && !self.storage.second_slot_is_empty(hash)\n }\n}\n\nimpl Debug for CountingBloomFilter\nwhere\n S: BloomStorage,\n{\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n let mut slots_used = 0;\n for i in 0..ARRAY_SIZE {\n if !self.storage.slot_is_empty(i) {\n slots_used += 1;\n }\n }\n write!(f, \"BloomFilter({}/{})\", slots_used, ARRAY_SIZE)\n }\n}\n\npub trait BloomStorage: Clone + Default {\n fn slot_is_empty(&self, index: usize) -> bool;\n fn adjust_slot(&mut self, index: usize, increment: bool);\n fn is_zeroed(&self) -> bool;\n\n #[inline]\n fn first_slot_is_empty(&self, hash: u32) -> bool {\n self.slot_is_empty(Self::first_slot_index(hash))\n }\n\n #[inline]\n fn second_slot_is_empty(&self, hash: u32) -> bool {\n self.slot_is_empty(Self::second_slot_index(hash))\n }\n\n #[inline]\n fn adjust_first_slot(&mut self, hash: u32, increment: bool) {\n self.adjust_slot(Self::first_slot_index(hash), increment)\n }\n\n #[inline]\n fn adjust_second_slot(&mut self, hash: u32, increment: bool) {\n self.adjust_slot(Self::second_slot_index(hash), increment)\n }\n\n #[inline]\n fn first_slot_index(hash: u32) -> usize {\n hash1(hash) as usize\n }\n\n #[inline]\n fn second_slot_index(hash: u32) -> usize {\n hash2(hash) as usize\n }\n}\n\n/// Storage class for a CountingBloomFilter that has 8-bit counters.\npub struct BloomStorageU8 {\n counters: [u8; ARRAY_SIZE],\n}\n\nimpl BloomStorage for BloomStorageU8 {\n #[inline]\n fn adjust_slot(&mut self, index: usize, increment: bool) {\n let slot = &mut self.counters[index];\n if *slot != 0xff {\n // full\n if increment {\n *slot += 1;\n } else {\n *slot -= 1;\n }\n }\n }\n\n #[inline]\n fn slot_is_empty(&self, index: usize) -> bool {\n self.counters[index] == 0\n }\n\n #[inline]\n fn is_zeroed(&self) -> bool {\n self.counters.iter().all(|x| *x == 0)\n }\n}\n\nimpl Default for BloomStorageU8 {\n fn default() -> Self {\n BloomStorageU8 {\n counters: [0; ARRAY_SIZE],\n }\n }\n}\n\nimpl Clone for BloomStorageU8 {\n fn clone(&self) -> Self {\n BloomStorageU8 {\n counters: self.counters,\n }\n }\n}\n\n/// Storage class for a CountingBloomFilter that has 1-bit counters.\npub struct BloomStorageBool {\n counters: [u8; ARRAY_SIZE / 8],\n}\n\nimpl BloomStorage for BloomStorageBool {\n #[inline]\n fn adjust_slot(&mut self, index: usize, increment: bool) {\n let bit = 1 << (index % 8);\n let byte = &mut self.counters[index / 8];\n\n // Since we have only one bit for storage, decrementing it\n // should never do anything. Assert against an accidental\n // decrementing of a bit that was never set.\n assert!(\n increment || (*byte & bit) != 0,\n \"should not decrement if slot is already false\"\n );\n\n if increment {\n *byte |= bit;\n }\n }\n\n #[inline]\n fn slot_is_empty(&self, index: usize) -> bool {\n let bit = 1 << (index % 8);\n (self.counters[index / 8] & bit) == 0\n }\n\n #[inline]\n fn is_zeroed(&self) -> bool {\n self.counters.iter().all(|x| *x == 0)\n }\n}\n\nimpl Default for BloomStorageBool {\n fn default() -> Self {\n BloomStorageBool {\n counters: [0; ARRAY_SIZE / 8],\n }\n }\n}\n\nimpl Clone for BloomStorageBool {\n fn clone(&self) -> Self {\n BloomStorageBool {\n counters: self.counters,\n }\n }\n}\n\n#[inline]\nfn hash1(hash: u32) -> u32 {\n hash & KEY_MASK\n}\n\n#[inline]\nfn hash2(hash: u32) -> u32 {\n (hash >> KEY_SIZE) & KEY_MASK\n}\n\n#[test]\nfn create_and_insert_some_stuff() {\n use rustc_hash::FxHasher;\n use std::hash::{Hash, Hasher};\n use std::mem::transmute;\n\n fn hash_as_str(i: usize) -> u32 {\n let mut hasher = FxHasher::default();\n let s = i.to_string();\n s.hash(&mut hasher);\n let hash: u64 = hasher.finish();\n (hash >> 32) as u32 ^ (hash as u32)\n }\n\n let mut bf = BloomFilter::new();\n\n // Statically assert that ARRAY_SIZE is a multiple of 8, which\n // BloomStorageBool relies on.\n unsafe {\n transmute::<[u8; ARRAY_SIZE % 8], [u8; 0]>([]);\n }\n\n for i in 0_usize..1000 {\n bf.insert_hash(hash_as_str(i));\n }\n\n for i in 0_usize..1000 {\n assert!(bf.might_contain_hash(hash_as_str(i)));\n }\n\n let false_positives = (1001_usize..2000)\n .filter(|i| bf.might_contain_hash(hash_as_str(*i)))\n .count();\n\n assert!(false_positives < 190, \"{} is not < 190\", false_positives); // 19%.\n\n for i in 0_usize..100 {\n bf.remove_hash(hash_as_str(i));\n }\n\n for i in 100_usize..1000 {\n assert!(bf.might_contain_hash(hash_as_str(i)));\n }\n\n let false_positives = (0_usize..100)\n .filter(|i| bf.might_contain_hash(hash_as_str(*i)))\n .count();\n\n assert!(false_positives < 20, \"{} is not < 20\", false_positives); // 20%.\n\n bf.clear();\n\n for i in 0_usize..2000 {\n assert!(!bf.might_contain_hash(hash_as_str(i)));\n }\n}\n\n#[cfg(feature = \"bench\")]\n#[cfg(test)]\nmod bench {\n extern crate test;\n use super::BloomFilter;\n\n #[derive(Default)]\n struct HashGenerator(u32);\n\n impl HashGenerator {\n fn next(&mut self) -> u32 {\n // Each hash is split into two twelve-bit segments, which are used\n // as an index into an array. We increment each by 64 so that we\n // hit the next cache line, and then another 1 so that our wrapping\n // behavior leads us to different entries each time.\n //\n // Trying to simulate cold caches is rather difficult with the cargo\n // benchmarking setup, so it may all be moot depending on the number\n // of iterations that end up being run. But we might as well.\n self.0 += (65) + (65 << super::KEY_SIZE);\n self.0\n }\n }\n\n #[bench]\n fn create_insert_1000_remove_100_lookup_100(b: &mut test::Bencher) {\n b.iter(|| {\n let mut gen1 = HashGenerator::default();\n let mut gen2 = HashGenerator::default();\n let mut bf = BloomFilter::new();\n for _ in 0_usize..1000 {\n bf.insert_hash(gen1.next());\n }\n for _ in 0_usize..100 {\n bf.remove_hash(gen2.next());\n }\n for _ in 100_usize..200 {\n test::black_box(bf.might_contain_hash(gen2.next()));\n }\n });\n }\n\n #[bench]\n fn might_contain_10(b: &mut test::Bencher) {\n let bf = BloomFilter::new();\n let mut gen = HashGenerator::default();\n b.iter(|| {\n for _ in 0..10 {\n test::black_box(bf.might_contain_hash(gen.next()));\n }\n });\n }\n\n #[bench]\n fn clear(b: &mut test::Bencher) {\n let mut bf = Box::new(BloomFilter::new());\n b.iter(|| test::black_box(&mut bf).clear());\n }\n\n #[bench]\n fn insert_10(b: &mut test::Bencher) {\n let mut bf = BloomFilter::new();\n let mut gen = HashGenerator::default();\n b.iter(|| {\n for _ in 0..10 {\n test::black_box(bf.insert_hash(gen.next()));\n }\n });\n }\n\n #[bench]\n fn remove_10(b: &mut test::Bencher) {\n let mut bf = BloomFilter::new();\n let mut gen = HashGenerator::default();\n // Note: this will underflow, and that's ok.\n b.iter(|| {\n for _ in 0..10 {\n bf.remove_hash(gen.next())\n }\n });\n }\n}\n" }, { "path": "selectors/build.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\nextern crate phf_codegen;\n\nuse std::env;\nuse std::fs::File;\nuse std::io::{BufWriter, Write};\nuse std::path::Path;\n\nfn main() {\n let path = Path::new(&env::var_os(\"OUT_DIR\").unwrap())\n .join(\"ascii_case_insensitive_html_attributes.rs\");\n let mut file = BufWriter::new(File::create(&path).unwrap());\n\n let mut set = phf_codegen::Set::new();\n for name in ASCII_CASE_INSENSITIVE_HTML_ATTRIBUTES.split_whitespace() {\n set.entry(name);\n }\n write!(\n &mut file,\n \"{{ static SET: ::phf::Set<&'static str> = {}; &SET }}\",\n set.build(),\n )\n .unwrap();\n}\n\n/// \nstatic ASCII_CASE_INSENSITIVE_HTML_ATTRIBUTES: &str = r#\"\n accept\n accept-charset\n align\n alink\n axis\n bgcolor\n charset\n checked\n clear\n codetype\n color\n compact\n declare\n defer\n dir\n direction\n disabled\n enctype\n face\n frame\n hreflang\n http-equiv\n lang\n language\n link\n media\n method\n multiple\n nohref\n noresize\n noshade\n nowrap\n readonly\n rel\n rev\n rules\n scope\n scrolling\n selected\n shape\n target\n text\n type\n valign\n valuetype\n vlink\n\"#;\n" }, { "path": "selectors/builder.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! Helper module to build up a selector safely and efficiently.\n//!\n//! Our selector representation is designed to optimize matching, and has\n//! several requirements:\n//! * All simple selectors and combinators are stored inline in the same buffer as Component\n//! instances.\n//! * We store the top-level compound selectors from right to left, i.e. in matching order.\n//! * We store the simple selectors for each combinator from left to right, so that we match the\n//! cheaper simple selectors first.\n//!\n//! For example, the selector:\n//!\n//! .bar:hover > .baz:nth-child(2) + .qux\n//!\n//! Gets stored as:\n//!\n//! [.qux, + , .baz, :nth-child(2), > , .bar, :hover]\n//!\n//! Meeting all these constraints without extra memmove traffic during parsing is non-trivial. This\n//! module encapsulates those details and presents an easy-to-use API for the parser.\n\nuse crate::parser::{\n Combinator, Component, ParseRelative, RelativeSelector, Selector, SelectorData, SelectorImpl,\n};\nuse crate::sink::Push;\nuse bitflags::bitflags;\nuse derive_more::{Add, AddAssign};\nuse servo_arc::Arc;\nuse smallvec::SmallVec;\nuse std::cmp;\nuse std::slice;\n\n#[cfg(feature = \"to_shmem\")]\nuse to_shmem_derive::ToShmem;\n\n/// Top-level SelectorBuilder struct. This should be stack-allocated by the consumer and never\n/// moved (because it contains a lot of inline data that would be slow to memmove).\n///\n/// After instantiation, callers may call the push_simple_selector() and push_combinator() methods\n/// to append selector data as it is encountered (from left to right). Once the process is\n/// complete, callers should invoke build(), which transforms the contents of the SelectorBuilder\n/// into a heap- allocated Selector and leaves the builder in a drained state.\n#[derive(Debug)]\npub struct SelectorBuilder {\n /// The entire sequence of components. We make this large because the result of parsing a\n /// selector is fed into a new Arc-ed allocation, so any spilled vec would be a wasted\n /// allocation. Also, Components are large enough that we don't have much cache locality\n /// benefit from reserving stack space for fewer of them.\n components: SmallVec<[Component; 32]>,\n last_compound_start: Option,\n}\n\nimpl Push> for SelectorBuilder {\n fn push(&mut self, value: Component) {\n self.push_simple_selector(value);\n }\n}\n\nimpl SelectorBuilder {\n /// Pushes a simple selector onto the current compound selector.\n #[inline(always)]\n pub fn push_simple_selector(&mut self, ss: Component) {\n debug_assert!(!ss.is_combinator());\n self.components.push(ss);\n }\n\n /// Completes the current compound selector and starts a new one, delimited by the given\n /// combinator.\n #[inline(always)]\n pub fn push_combinator(&mut self, c: Combinator) {\n self.reverse_last_compound();\n self.components.push(Component::Combinator(c));\n self.last_compound_start = Some(self.components.len());\n }\n\n fn reverse_last_compound(&mut self) {\n let start = self.last_compound_start.unwrap_or(0);\n self.components[start..].reverse();\n }\n\n /// Returns true if combinators have ever been pushed to this builder.\n #[inline(always)]\n pub fn has_combinators(&self) -> bool {\n self.last_compound_start.is_some()\n }\n\n /// Consumes the builder, producing a Selector.\n #[inline(always)]\n pub fn build(&mut self, parse_relative: ParseRelative) -> SelectorData {\n // Compute the specificity and flags.\n let sf = specificity_and_flags(\n self.components.iter(),\n /* for_nesting_parent = */ false,\n );\n self.build_with_specificity_and_flags(sf, parse_relative)\n }\n\n /// Builds with an explicit SpecificityAndFlags. This is separated from build() so that unit\n /// tests can pass an explicit specificity.\n #[inline(always)]\n pub(crate) fn build_with_specificity_and_flags(\n &mut self,\n mut spec: SpecificityAndFlags,\n parse_relative: ParseRelative,\n ) -> SelectorData {\n let implicit_addition = match parse_relative {\n ParseRelative::ForNesting if !spec.flags.intersects(SelectorFlags::HAS_PARENT) => {\n Some((Component::ParentSelector, SelectorFlags::HAS_PARENT))\n },\n ParseRelative::ForScope\n if !spec\n .flags\n .intersects(SelectorFlags::HAS_SCOPE | SelectorFlags::HAS_PARENT) =>\n {\n Some((Component::ImplicitScope, SelectorFlags::HAS_SCOPE))\n },\n _ => None,\n };\n let implicit_selector_and_combinator;\n let implicit_selector = if let Some((component, flag)) = implicit_addition {\n spec.flags.insert(flag);\n implicit_selector_and_combinator =\n [Component::Combinator(Combinator::Descendant), component];\n &implicit_selector_and_combinator[..]\n } else {\n &[]\n };\n\n // As an optimization, for a selector without combinators, we can just keep the order\n // as-is.\n if self.last_compound_start.is_none() {\n return Arc::from_header_and_iter(\n spec,\n ExactChain(self.components.drain(..), implicit_selector.iter().cloned()),\n );\n }\n\n self.reverse_last_compound();\n Arc::from_header_and_iter(\n spec,\n ExactChain(\n self.components.drain(..).rev(),\n implicit_selector.iter().cloned(),\n ),\n )\n }\n}\n\nimpl Default for SelectorBuilder {\n #[inline(always)]\n fn default() -> Self {\n SelectorBuilder {\n components: SmallVec::new(),\n last_compound_start: None,\n }\n }\n}\n\n// This is effectively a Chain<>, but Chain isn't an ExactSizeIterator, see\n// https://github.com/rust-lang/rust/issues/34433\nstruct ExactChain(A, B);\n\nimpl ExactSizeIterator for ExactChain\nwhere\n A: ExactSizeIterator,\n B: ExactSizeIterator,\n{\n fn len(&self) -> usize {\n self.0.len() + self.1.len()\n }\n}\n\nimpl Iterator for ExactChain\nwhere\n A: ExactSizeIterator,\n B: ExactSizeIterator,\n{\n type Item = Item;\n\n #[inline(always)]\n fn next(&mut self) -> Option {\n self.0.next().or_else(|| self.1.next())\n }\n\n fn size_hint(&self) -> (usize, Option) {\n let len = self.len();\n (len, Some(len))\n }\n}\n\n/// Flags that indicate at which point of parsing a selector are we.\n#[derive(Clone, Copy, Default, Eq, PartialEq)]\n#[cfg_attr(feature = \"to_shmem\", derive(ToShmem))]\npub(crate) struct SelectorFlags(u8);\n\nbitflags! {\n impl SelectorFlags: u8 {\n const HAS_PSEUDO = 1 << 0;\n const HAS_SLOTTED = 1 << 1;\n const HAS_PART = 1 << 2;\n const HAS_PARENT = 1 << 3;\n const HAS_HOST = 1 << 4;\n const HAS_SCOPE = 1 << 5;\n }\n}\n\nimpl core::fmt::Debug for SelectorFlags {\n fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {\n if self.is_empty() {\n write!(f, \"{:#x}\", Self::empty().bits())\n } else {\n bitflags::parser::to_writer(self, f)\n }\n }\n}\n\nimpl SelectorFlags {\n /// When you nest a pseudo-element with something like:\n ///\n /// ::before { & { .. } }\n ///\n /// It is not supposed to work, because :is(::before) is invalid. We can't propagate the\n /// pseudo-flags from inner to outer selectors, to avoid breaking our invariants.\n pub(crate) fn forbidden_for_nesting() -> Self {\n Self::HAS_PSEUDO | Self::HAS_SLOTTED | Self::HAS_PART\n }\n}\n\n#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]\n#[cfg_attr(feature = \"to_shmem\", derive(ToShmem))]\npub struct SpecificityAndFlags {\n /// There are two free bits here, since we use ten bits for each specificity\n /// kind (id, class, element).\n pub(crate) specificity: u32,\n /// There's padding after this field due to the size of the flags.\n pub(crate) flags: SelectorFlags,\n}\n\nconst MAX_10BIT: u32 = (1u32 << 10) - 1;\n\n#[derive(Add, AddAssign, Clone, Copy, Default, Eq, Ord, PartialEq, PartialOrd)]\npub(crate) struct Specificity {\n id_selectors: u32,\n class_like_selectors: u32,\n element_selectors: u32,\n}\n\nimpl Specificity {\n // Return the specficity of a single class-like selector.\n #[inline]\n pub fn single_class_like() -> Self {\n Specificity {\n id_selectors: 0,\n class_like_selectors: 1,\n element_selectors: 0,\n }\n }\n}\n\nimpl From for Specificity {\n #[inline]\n fn from(value: u32) -> Specificity {\n assert!(value <= MAX_10BIT << 20 | MAX_10BIT << 10 | MAX_10BIT);\n Specificity {\n id_selectors: value >> 20,\n class_like_selectors: (value >> 10) & MAX_10BIT,\n element_selectors: value & MAX_10BIT,\n }\n }\n}\n\nimpl From for u32 {\n #[inline]\n fn from(specificity: Specificity) -> u32 {\n cmp::min(specificity.id_selectors, MAX_10BIT) << 20\n | cmp::min(specificity.class_like_selectors, MAX_10BIT) << 10\n | cmp::min(specificity.element_selectors, MAX_10BIT)\n }\n}\n\nfn specificity_and_flags(\n iter: slice::Iter>,\n for_nesting_parent: bool,\n) -> SpecificityAndFlags\nwhere\n Impl: SelectorImpl,\n{\n fn component_specificity(\n simple_selector: &Component,\n specificity: &mut Specificity,\n flags: &mut SelectorFlags,\n for_nesting_parent: bool,\n ) where\n Impl: SelectorImpl,\n {\n match *simple_selector {\n Component::Combinator(..) => {},\n Component::ParentSelector => flags.insert(SelectorFlags::HAS_PARENT),\n Component::Part(..) => {\n flags.insert(SelectorFlags::HAS_PART);\n if !for_nesting_parent {\n specificity.element_selectors += 1\n }\n },\n Component::PseudoElement(ref pseudo) => {\n use crate::parser::PseudoElement;\n flags.insert(SelectorFlags::HAS_PSEUDO);\n if !for_nesting_parent {\n specificity.element_selectors += pseudo.specificity_count();\n }\n },\n Component::LocalName(..) => specificity.element_selectors += 1,\n Component::Slotted(ref selector) => {\n flags.insert(SelectorFlags::HAS_SLOTTED);\n if !for_nesting_parent {\n specificity.element_selectors += 1;\n // Note that due to the way ::slotted works we only compete with\n // other ::slotted rules, so the above rule doesn't really\n // matter, but we do it still for consistency with other\n // pseudo-elements.\n //\n // See: https://github.com/w3c/csswg-drafts/issues/1915\n *specificity += Specificity::from(selector.specificity());\n }\n flags.insert(selector.flags());\n },\n Component::Host(ref selector) => {\n flags.insert(SelectorFlags::HAS_HOST);\n specificity.class_like_selectors += 1;\n if let Some(ref selector) = *selector {\n // See: https://github.com/w3c/csswg-drafts/issues/1915\n *specificity += Specificity::from(selector.specificity());\n flags.insert(selector.flags());\n }\n },\n Component::ID(..) => {\n specificity.id_selectors += 1;\n },\n Component::Class(..)\n | Component::AttributeInNoNamespace { .. }\n | Component::AttributeInNoNamespaceExists { .. }\n | Component::AttributeOther(..)\n | Component::Root\n | Component::Empty\n | Component::Nth(..)\n | Component::NonTSPseudoClass(..) => {\n specificity.class_like_selectors += 1;\n },\n Component::Scope | Component::ImplicitScope => {\n flags.insert(SelectorFlags::HAS_SCOPE);\n if matches!(*simple_selector, Component::Scope) {\n specificity.class_like_selectors += 1;\n }\n },\n Component::NthOf(ref nth_of_data) => {\n // https://drafts.csswg.org/selectors/#specificity-rules:\n //\n // The specificity of the :nth-last-child() pseudo-class,\n // like the :nth-child() pseudo-class, combines the\n // specificity of a regular pseudo-class with that of its\n // selector argument S.\n specificity.class_like_selectors += 1;\n let sf = selector_list_specificity_and_flags(\n nth_of_data.selectors().iter(),\n for_nesting_parent,\n );\n *specificity += Specificity::from(sf.specificity);\n flags.insert(sf.flags);\n },\n // https://drafts.csswg.org/selectors/#specificity-rules:\n //\n // The specificity of an :is(), :not(), or :has() pseudo-class\n // is replaced by the specificity of the most specific complex\n // selector in its selector list argument.\n Component::Where(ref list)\n | Component::Negation(ref list)\n | Component::Is(ref list) => {\n let sf = selector_list_specificity_and_flags(\n list.slice().iter(),\n /* nested = */ true,\n );\n if !matches!(*simple_selector, Component::Where(..)) {\n *specificity += Specificity::from(sf.specificity);\n }\n flags.insert(sf.flags);\n },\n Component::Has(ref relative_selectors) => {\n let sf = relative_selector_list_specificity_and_flags(\n relative_selectors,\n for_nesting_parent,\n );\n *specificity += Specificity::from(sf.specificity);\n flags.insert(sf.flags);\n },\n Component::ExplicitUniversalType\n | Component::ExplicitAnyNamespace\n | Component::ExplicitNoNamespace\n | Component::DefaultNamespace(..)\n | Component::Namespace(..)\n | Component::RelativeSelectorAnchor\n | Component::Invalid(..) => {\n // Does not affect specificity\n },\n }\n }\n\n let mut specificity = Default::default();\n let mut flags = Default::default();\n for simple_selector in iter {\n component_specificity(\n &simple_selector,\n &mut specificity,\n &mut flags,\n for_nesting_parent,\n );\n }\n SpecificityAndFlags {\n specificity: specificity.into(),\n flags,\n }\n}\n\n/// Finds the maximum specificity of elements in the list and returns it.\npub(crate) fn selector_list_specificity_and_flags<'a, Impl: SelectorImpl>(\n itr: impl Iterator>,\n for_nesting_parent: bool,\n) -> SpecificityAndFlags {\n let mut specificity = 0;\n let mut flags = SelectorFlags::empty();\n for selector in itr {\n let selector_flags = selector.flags();\n let selector_specificity = if for_nesting_parent\n && selector_flags.intersects(SelectorFlags::forbidden_for_nesting())\n {\n // In this case we need to re-compute the specificity.\n specificity_and_flags(selector.iter_raw_match_order(), for_nesting_parent).specificity\n } else {\n selector.specificity()\n };\n specificity = std::cmp::max(specificity, selector_specificity);\n flags.insert(selector.flags());\n }\n SpecificityAndFlags { specificity, flags }\n}\n\npub(crate) fn relative_selector_list_specificity_and_flags(\n list: &[RelativeSelector],\n for_nesting_parent: bool,\n) -> SpecificityAndFlags {\n selector_list_specificity_and_flags(list.iter().map(|rel| &rel.selector), for_nesting_parent)\n}\n" }, { "path": "selectors/context.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\nuse crate::attr::CaseSensitivity;\nuse crate::bloom::BloomFilter;\nuse crate::nth_index_cache::{NthIndexCache, NthIndexCacheInner};\nuse crate::parser::{Selector, SelectorImpl};\nuse crate::relative_selector::cache::RelativeSelectorCache;\nuse crate::relative_selector::filter::RelativeSelectorFilterMap;\nuse crate::tree::{Element, OpaqueElement};\n\n/// What kind of selector matching mode we should use.\n///\n/// There are two modes of selector matching. The difference is only noticeable\n/// in presence of pseudo-elements.\n#[derive(Clone, Copy, Debug, PartialEq)]\npub enum MatchingMode {\n /// Don't ignore any pseudo-element selectors.\n Normal,\n\n /// Ignores any stateless pseudo-element selectors in the rightmost sequence\n /// of simple selectors.\n ///\n /// This is useful, for example, to match against ::before when you aren't a\n /// pseudo-element yourself.\n ///\n /// For example, in presence of `::before:hover`, it would never match, but\n /// `::before` would be ignored as in \"matching\".\n ///\n /// It's required for all the selectors you match using this mode to have a\n /// pseudo-element.\n ForStatelessPseudoElement,\n}\n\n/// The mode to use when matching unvisited and visited links.\n#[derive(Clone, Copy, Debug, Eq, PartialEq)]\npub enum VisitedHandlingMode {\n /// All links are matched as if they are unvisted.\n AllLinksUnvisited,\n /// All links are matched as if they are visited and unvisited (both :link\n /// and :visited match).\n ///\n /// This is intended to be used from invalidation code, to be conservative\n /// about whether we need to restyle a link.\n AllLinksVisitedAndUnvisited,\n /// A element's \"relevant link\" is the element being matched if it is a link\n /// or the nearest ancestor link. The relevant link is matched as though it\n /// is visited, and all other links are matched as if they are unvisited.\n RelevantLinkVisited,\n}\n\nimpl VisitedHandlingMode {\n #[inline]\n pub fn matches_visited(&self) -> bool {\n matches!(\n *self,\n VisitedHandlingMode::RelevantLinkVisited\n | VisitedHandlingMode::AllLinksVisitedAndUnvisited\n )\n }\n\n #[inline]\n pub fn matches_unvisited(&self) -> bool {\n matches!(\n *self,\n VisitedHandlingMode::AllLinksUnvisited\n | VisitedHandlingMode::AllLinksVisitedAndUnvisited\n )\n }\n}\n\n/// Whether we need to set selector invalidation flags on elements for this\n/// match request.\n#[derive(Clone, Copy, Debug, PartialEq)]\npub enum NeedsSelectorFlags {\n No,\n Yes,\n}\n\n/// Whether we're matching in the contect of invalidation.\n#[derive(Clone, Copy, PartialEq)]\npub enum MatchingForInvalidation {\n No,\n Yes,\n YesForComparison,\n}\n\nimpl MatchingForInvalidation {\n /// Are we matching for invalidation?\n pub fn is_for_invalidation(&self) -> bool {\n matches!(*self, Self::Yes | Self::YesForComparison)\n }\n}\n\n/// Which quirks mode is this document in.\n///\n/// See: https://quirks.spec.whatwg.org/\n#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]\npub enum QuirksMode {\n /// Quirks mode.\n Quirks,\n /// Limited quirks mode.\n LimitedQuirks,\n /// No quirks mode.\n NoQuirks,\n}\n\nimpl QuirksMode {\n #[inline]\n pub fn classes_and_ids_case_sensitivity(self) -> CaseSensitivity {\n match self {\n QuirksMode::NoQuirks | QuirksMode::LimitedQuirks => CaseSensitivity::CaseSensitive,\n QuirksMode::Quirks => CaseSensitivity::AsciiCaseInsensitive,\n }\n }\n}\n\n/// Set of caches (And cache-likes) that speed up expensive selector matches.\n#[derive(Default)]\npub struct SelectorCaches {\n /// A cache to speed up nth-index-like selectors.\n pub nth_index: NthIndexCache,\n /// A cache to speed up relative selector matches. See module documentation.\n pub relative_selector: RelativeSelectorCache,\n /// A map of bloom filters to fast-reject relative selector matches.\n pub relative_selector_filter_map: RelativeSelectorFilterMap,\n}\n\n/// Data associated with the matching process for a element. This context is\n/// used across many selectors for an element, so it's not appropriate for\n/// transient data that applies to only a single selector.\npub struct MatchingContext<'a, Impl>\nwhere\n Impl: SelectorImpl,\n{\n /// Input with the matching mode we should use when matching selectors.\n matching_mode: MatchingMode,\n /// Input with the bloom filter used to fast-reject selectors.\n pub bloom_filter: Option<&'a BloomFilter>,\n /// The element which is going to match :scope pseudo-class. It can be\n /// either one :scope element, or the scoping element.\n ///\n /// Note that, although in theory there can be multiple :scope elements,\n /// in current specs, at most one is specified, and when there is one,\n /// scoping element is not relevant anymore, so we use a single field for\n /// them.\n ///\n /// When this is None, :scope will match the root element.\n ///\n /// See https://drafts.csswg.org/selectors-4/#scope-pseudo\n pub scope_element: Option,\n\n /// The current shadow host we're collecting :host rules for.\n pub current_host: Option,\n\n /// Controls how matching for links is handled.\n visited_handling: VisitedHandlingMode,\n\n /// Whether we're currently matching a featureless element.\n pub featureless: bool,\n\n /// The current nesting level of selectors that we're matching.\n nesting_level: usize,\n\n /// Whether we're inside a negation or not.\n in_negation: bool,\n\n /// An optional hook function for checking whether a pseudo-element\n /// should match when matching_mode is ForStatelessPseudoElement.\n pub pseudo_element_matching_fn: Option<&'a dyn Fn(&Impl::PseudoElement) -> bool>,\n\n /// Extra implementation-dependent matching data.\n pub extra_data: Impl::ExtraMatchingData<'a>,\n\n /// The current element we're anchoring on for evaluating the relative selector.\n current_relative_selector_anchor: Option,\n\n quirks_mode: QuirksMode,\n needs_selector_flags: NeedsSelectorFlags,\n\n /// Whether we're matching in the context of invalidation.\n matching_for_invalidation: MatchingForInvalidation,\n\n /// Whether we're matching in the context of revalidation.\n matching_for_revalidation: bool,\n\n /// Caches to speed up expensive selector matches.\n pub selector_caches: &'a mut SelectorCaches,\n\n classes_and_ids_case_sensitivity: CaseSensitivity,\n _impl: ::std::marker::PhantomData,\n}\n\nimpl<'a, Impl> MatchingContext<'a, Impl>\nwhere\n Impl: SelectorImpl,\n{\n /// Constructs a new `MatchingContext`.\n pub fn new(\n matching_mode: MatchingMode,\n bloom_filter: Option<&'a BloomFilter>,\n selector_caches: &'a mut SelectorCaches,\n quirks_mode: QuirksMode,\n needs_selector_flags: NeedsSelectorFlags,\n matching_for_invalidation: MatchingForInvalidation,\n ) -> Self {\n Self::new_internal(\n matching_mode,\n bloom_filter,\n selector_caches,\n VisitedHandlingMode::AllLinksUnvisited,\n quirks_mode,\n needs_selector_flags,\n matching_for_invalidation,\n false,\n )\n }\n\n /// Constructs a new `MatchingContext` for revalidation.\n pub fn new_for_revalidation(\n bloom_filter: Option<&'a BloomFilter>,\n selector_caches: &'a mut SelectorCaches,\n quirks_mode: QuirksMode,\n needs_selector_flags: NeedsSelectorFlags,\n ) -> Self {\n Self::new_internal(\n // NB: `MatchingMode` doesn't really matter, given we don't share style\n // between pseudos.\n MatchingMode::Normal,\n bloom_filter,\n selector_caches,\n VisitedHandlingMode::AllLinksUnvisited,\n quirks_mode,\n needs_selector_flags,\n MatchingForInvalidation::No,\n true,\n )\n }\n\n /// Constructs a new `MatchingContext` for use in visited matching.\n pub fn new_for_visited(\n matching_mode: MatchingMode,\n bloom_filter: Option<&'a BloomFilter>,\n selector_caches: &'a mut SelectorCaches,\n visited_handling: VisitedHandlingMode,\n quirks_mode: QuirksMode,\n needs_selector_flags: NeedsSelectorFlags,\n matching_for_invalidation: MatchingForInvalidation,\n ) -> Self {\n Self::new_internal(\n matching_mode,\n bloom_filter,\n selector_caches,\n visited_handling,\n quirks_mode,\n needs_selector_flags,\n matching_for_invalidation,\n false,\n )\n }\n\n fn new_internal(\n matching_mode: MatchingMode,\n bloom_filter: Option<&'a BloomFilter>,\n selector_caches: &'a mut SelectorCaches,\n visited_handling: VisitedHandlingMode,\n quirks_mode: QuirksMode,\n needs_selector_flags: NeedsSelectorFlags,\n matching_for_invalidation: MatchingForInvalidation,\n matching_for_revalidation: bool,\n ) -> Self {\n Self {\n matching_mode,\n bloom_filter,\n visited_handling,\n quirks_mode,\n classes_and_ids_case_sensitivity: quirks_mode.classes_and_ids_case_sensitivity(),\n needs_selector_flags,\n matching_for_invalidation,\n matching_for_revalidation,\n scope_element: None,\n current_host: None,\n featureless: false,\n nesting_level: 0,\n in_negation: false,\n pseudo_element_matching_fn: None,\n extra_data: Default::default(),\n current_relative_selector_anchor: None,\n selector_caches,\n _impl: ::std::marker::PhantomData,\n }\n }\n\n // Grab a reference to the appropriate cache.\n #[inline]\n pub fn nth_index_cache(\n &mut self,\n is_of_type: bool,\n is_from_end: bool,\n selectors: &[Selector],\n ) -> &mut NthIndexCacheInner {\n self.selector_caches\n .nth_index\n .get(is_of_type, is_from_end, selectors)\n }\n\n /// Whether we're matching a nested selector.\n #[inline]\n pub fn is_nested(&self) -> bool {\n self.nesting_level != 0\n }\n\n /// Whether we're matching inside a :not(..) selector.\n #[inline]\n pub fn in_negation(&self) -> bool {\n self.in_negation\n }\n\n /// The quirks mode of the document.\n #[inline]\n pub fn quirks_mode(&self) -> QuirksMode {\n self.quirks_mode\n }\n\n /// The matching-mode for this selector-matching operation.\n #[inline]\n pub fn matching_mode(&self) -> MatchingMode {\n self.matching_mode\n }\n\n /// Whether we need to set selector flags.\n #[inline]\n pub fn needs_selector_flags(&self) -> bool {\n self.needs_selector_flags == NeedsSelectorFlags::Yes\n }\n\n /// Whether or not we're matching to invalidate.\n #[inline]\n pub fn matching_for_invalidation(&self) -> bool {\n self.matching_for_invalidation.is_for_invalidation()\n }\n\n /// Whether or not we're matching to revalidate.\n #[inline]\n pub fn matching_for_revalidation(&self) -> bool {\n self.matching_for_revalidation\n }\n\n /// Whether or not we're comparing for invalidation, if we are matching for invalidation.\n #[inline]\n pub fn matching_for_invalidation_comparison(&self) -> Option {\n match self.matching_for_invalidation {\n MatchingForInvalidation::No => None,\n MatchingForInvalidation::Yes => Some(false),\n MatchingForInvalidation::YesForComparison => Some(true),\n }\n }\n\n /// Run the given matching function for before/after invalidation comparison.\n #[inline]\n pub fn for_invalidation_comparison(&mut self, f: F) -> R\n where\n F: FnOnce(&mut Self) -> R,\n {\n debug_assert!(\n self.matching_for_invalidation(),\n \"Not matching for invalidation?\"\n );\n let prev = self.matching_for_invalidation;\n self.matching_for_invalidation = MatchingForInvalidation::YesForComparison;\n let result = f(self);\n self.matching_for_invalidation = prev;\n result\n }\n\n /// The case-sensitivity for class and ID selectors\n #[inline]\n pub fn classes_and_ids_case_sensitivity(&self) -> CaseSensitivity {\n self.classes_and_ids_case_sensitivity\n }\n\n /// Runs F with a deeper nesting level.\n #[inline]\n pub fn nest(&mut self, f: F) -> R\n where\n F: FnOnce(&mut Self) -> R,\n {\n self.nesting_level += 1;\n let result = f(self);\n self.nesting_level -= 1;\n result\n }\n\n /// Runs F with a deeper nesting level, and marking ourselves in a negation,\n /// for a :not(..) selector, for example.\n #[inline]\n pub fn nest_for_negation(&mut self, f: F) -> R\n where\n F: FnOnce(&mut Self) -> R,\n {\n let old_in_negation = self.in_negation;\n self.in_negation = !self.in_negation;\n let result = self.nest(f);\n self.in_negation = old_in_negation;\n result\n }\n\n #[inline]\n pub fn visited_handling(&self) -> VisitedHandlingMode {\n self.visited_handling\n }\n\n /// Runs F with a different featureless element flag.\n #[inline]\n pub fn with_featureless(&mut self, featureless: bool, f: F) -> R\n where\n F: FnOnce(&mut Self) -> R,\n {\n let orig = self.featureless;\n self.featureless = featureless;\n let result = f(self);\n self.featureless = orig;\n result\n }\n\n /// Returns whether the currently matching element is acting as a featureless element (e.g.,\n /// because we've crossed a shadow boundary). This is used to implement the :host selector\n /// rules properly.\n #[inline]\n pub fn featureless(&self) -> bool {\n self.featureless\n }\n\n /// Runs F with a different VisitedHandlingMode.\n #[inline]\n pub fn with_visited_handling_mode(\n &mut self,\n handling_mode: VisitedHandlingMode,\n f: F,\n ) -> R\n where\n F: FnOnce(&mut Self) -> R,\n {\n let original_handling_mode = self.visited_handling;\n self.visited_handling = handling_mode;\n let result = f(self);\n self.visited_handling = original_handling_mode;\n result\n }\n\n /// Runs F with a given shadow host which is the root of the tree whose\n /// rules we're matching.\n #[inline]\n pub fn with_shadow_host(&mut self, host: Option, f: F) -> R\n where\n E: Element,\n F: FnOnce(&mut Self) -> R,\n {\n let original_host = self.current_host.take();\n self.current_host = host.map(|h| h.opaque());\n let result = f(self);\n self.current_host = original_host;\n result\n }\n\n /// Returns the current shadow host whose shadow root we're matching rules\n /// against.\n #[inline]\n pub fn shadow_host(&self) -> Option {\n self.current_host\n }\n\n /// Runs F with a deeper nesting level, with the given element as the anchor,\n /// for a :has(...) selector, for example.\n #[inline]\n pub fn nest_for_relative_selector(&mut self, anchor: OpaqueElement, f: F) -> R\n where\n F: FnOnce(&mut Self) -> R,\n {\n debug_assert!(\n self.current_relative_selector_anchor.is_none(),\n \"Nesting should've been rejected at parse time\"\n );\n self.current_relative_selector_anchor = Some(anchor);\n let result = self.nest(f);\n self.current_relative_selector_anchor = None;\n result\n }\n\n /// Runs F with a deeper nesting level, with the given element as the scope.\n #[inline]\n pub fn nest_for_scope(&mut self, scope: Option, f: F) -> R\n where\n F: FnOnce(&mut Self) -> R,\n {\n let original_scope_element = self.scope_element;\n self.scope_element = scope;\n let result = f(self);\n self.scope_element = original_scope_element;\n result\n }\n\n /// Runs F with a deeper nesting level, with the given element as the scope, for\n /// matching `scope-start` and/or `scope-end` conditions.\n #[inline]\n pub fn nest_for_scope_condition(&mut self, scope: Option, f: F) -> R\n where\n F: FnOnce(&mut Self) -> R,\n {\n let original_matching_mode = self.matching_mode;\n // We may as well be matching for a pseudo-element inside `@scope`, but\n // the scope-defining selectors wouldn't be matching them.\n self.matching_mode = MatchingMode::Normal;\n let result = self.nest_for_scope(scope, f);\n self.matching_mode = original_matching_mode;\n result\n }\n\n /// Returns the current anchor element to evaluate the relative selector against.\n #[inline]\n pub fn relative_selector_anchor(&self) -> Option {\n self.current_relative_selector_anchor\n }\n}\n" }, { "path": "selectors/kleene_value.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! Kleen logic: https://en.wikipedia.org/wiki/Three-valued_logic#Kleene_and_Priest_logics\n\n/// A \"trilean\" value based on Kleen logic.\n#[derive(Clone, Copy, Debug, Eq, PartialEq)]\npub enum KleeneValue {\n /// False\n False = 0,\n /// True\n True = 1,\n /// Either true or false, but we’re not sure which yet.\n Unknown,\n}\n\nimpl From for KleeneValue {\n fn from(b: bool) -> Self {\n if b {\n Self::True\n } else {\n Self::False\n }\n }\n}\n\nimpl KleeneValue {\n /// Turns this Kleene value to a bool, taking the unknown value as an\n /// argument.\n pub fn to_bool(self, unknown: bool) -> bool {\n match self {\n Self::True => true,\n Self::False => false,\n Self::Unknown => unknown,\n }\n }\n\n /// Return true if any result of f() is definitely true.\n /// Otherwise, return the `or` of all values.\n /// Returns false if empty, like that of `Iterator`.\n #[inline(always)]\n pub fn any(iter: impl Iterator, f: impl FnMut(T) -> Self) -> Self {\n Self::any_value(iter, Self::True, Self::False, |a, b| a | b, f)\n }\n\n /// Return false if any results of f() is definitely false.\n /// Otherwise, return the `and` of all values.\n /// Returns true if empty, opposite of `Iterator`.\n #[inline(always)]\n pub fn any_false(iter: impl Iterator, f: impl FnMut(T) -> Self) -> Self {\n Self::any_value(iter, Self::False, Self::True, |a, b| a & b, f)\n }\n\n #[inline(always)]\n fn any_value(\n iter: impl Iterator,\n value: Self,\n on_empty: Self,\n op: impl Fn(Self, Self) -> Self,\n mut f: impl FnMut(T) -> Self,\n ) -> Self {\n let mut result = None;\n for item in iter {\n let r = f(item);\n if r == value {\n return r;\n }\n if let Some(v) = result.as_mut() {\n *v = op(*v, r);\n } else {\n result = Some(r);\n }\n }\n result.unwrap_or(on_empty)\n }\n}\n\nimpl std::ops::Not for KleeneValue {\n type Output = Self;\n\n fn not(self) -> Self {\n match self {\n Self::True => Self::False,\n Self::False => Self::True,\n Self::Unknown => Self::Unknown,\n }\n }\n}\n\n// Implements the logical and operation.\nimpl std::ops::BitAnd for KleeneValue {\n type Output = Self;\n\n fn bitand(self, other: Self) -> Self {\n if self == Self::False || other == Self::False {\n return Self::False;\n }\n if self == Self::Unknown || other == Self::Unknown {\n return Self::Unknown;\n }\n Self::True\n }\n}\n\n// Implements the logical or operation.\nimpl std::ops::BitOr for KleeneValue {\n type Output = Self;\n\n fn bitor(self, other: Self) -> Self {\n if self == Self::True || other == Self::True {\n return Self::True;\n }\n if self == Self::Unknown || other == Self::Unknown {\n return Self::Unknown;\n }\n Self::False\n }\n}\n\nimpl std::ops::BitOrAssign for KleeneValue {\n fn bitor_assign(&mut self, other: Self) {\n *self = *self | other;\n }\n}\n\nimpl std::ops::BitAndAssign for KleeneValue {\n fn bitand_assign(&mut self, other: Self) {\n *self = *self & other;\n }\n}\n" }, { "path": "selectors/lib.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n// Make |cargo bench| work.\n#![cfg_attr(feature = \"bench\", feature(test))]\n\npub mod attr;\npub mod bloom;\nmod builder;\npub mod context;\npub mod kleene_value;\npub mod matching;\nmod nth_index_cache;\npub mod parser;\npub mod relative_selector;\npub mod sink;\nmod tree;\npub mod visitor;\n\npub use crate::nth_index_cache::NthIndexCache;\npub use crate::parser::{Parser, SelectorImpl, SelectorList};\npub use crate::tree::{Element, OpaqueElement};\n" }, { "path": "selectors/matching.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\nuse crate::attr::{\n AttrSelectorOperation, AttrSelectorWithOptionalNamespace, CaseSensitivity, NamespaceConstraint,\n ParsedAttrSelectorOperation, ParsedCaseSensitivity,\n};\nuse crate::bloom::{BloomFilter, BLOOM_HASH_MASK};\nuse crate::kleene_value::KleeneValue;\nuse crate::parser::{\n AncestorHashes, Combinator, Component, LocalName, MatchesFeaturelessHost, NthSelectorData,\n RelativeSelectorMatchHint,\n};\nuse crate::parser::{\n NonTSPseudoClass, RelativeSelector, Selector, SelectorImpl, SelectorIter, SelectorList,\n};\nuse crate::relative_selector::cache::RelativeSelectorCachedMatch;\nuse crate::tree::Element;\nuse bitflags::bitflags;\nuse debug_unreachable::debug_unreachable;\nuse log::debug;\nuse smallvec::SmallVec;\nuse std::borrow::Borrow;\n\npub use crate::context::*;\n\n// The bloom filter for descendant CSS selectors will have a <1% false\n// positive rate until it has this many selectors in it, then it will\n// rapidly increase.\npub static RECOMMENDED_SELECTOR_BLOOM_FILTER_SIZE: usize = 4096;\n\nbitflags! {\n /// Set of flags that are set on either the element or its parent (depending\n /// on the flag) if the element could potentially match a selector.\n #[derive(Clone, Copy)]\n pub struct ElementSelectorFlags: usize {\n /// When a child is added or removed from the parent, all the children\n /// must be restyled, because they may match :nth-last-child,\n /// :last-of-type, :nth-last-of-type, or :only-of-type.\n const HAS_SLOW_SELECTOR = 1 << 0;\n\n /// When a child is added or removed from the parent, any later\n /// children must be restyled, because they may match :nth-child,\n /// :first-of-type, or :nth-of-type.\n const HAS_SLOW_SELECTOR_LATER_SIBLINGS = 1 << 1;\n\n /// HAS_SLOW_SELECTOR* was set by the presence of :nth (But not of).\n const HAS_SLOW_SELECTOR_NTH = 1 << 2;\n\n /// When a DOM mutation occurs on a child that might be matched by\n /// :nth-last-child(.. of ), earlier children must be\n /// restyled, and HAS_SLOW_SELECTOR will be set (which normally\n /// indicates that all children will be restyled).\n ///\n /// Similarly, when a DOM mutation occurs on a child that might be\n /// matched by :nth-child(.. of ), later children must be\n /// restyled, and HAS_SLOW_SELECTOR_LATER_SIBLINGS will be set.\n const HAS_SLOW_SELECTOR_NTH_OF = 1 << 3;\n\n /// When a child is added or removed from the parent, the first and\n /// last children must be restyled, because they may match :first-child,\n /// :last-child, or :only-child.\n const HAS_EDGE_CHILD_SELECTOR = 1 << 4;\n\n /// The element has an empty selector, so when a child is appended we\n /// might need to restyle the parent completely.\n const HAS_EMPTY_SELECTOR = 1 << 5;\n\n /// The element may anchor a relative selector.\n const ANCHORS_RELATIVE_SELECTOR = 1 << 6;\n\n /// The element may anchor a relative selector that is not the subject\n /// of the whole selector.\n const ANCHORS_RELATIVE_SELECTOR_NON_SUBJECT = 1 << 7;\n\n /// The element is reached by a relative selector search in the sibling direction.\n const RELATIVE_SELECTOR_SEARCH_DIRECTION_SIBLING = 1 << 8;\n\n /// The element is reached by a relative selector search in the ancestor direction.\n const RELATIVE_SELECTOR_SEARCH_DIRECTION_ANCESTOR = 1 << 9;\n\n // The element is reached by a relative selector search in both sibling and ancestor directions.\n const RELATIVE_SELECTOR_SEARCH_DIRECTION_ANCESTOR_SIBLING =\n Self::RELATIVE_SELECTOR_SEARCH_DIRECTION_SIBLING.bits() |\n Self::RELATIVE_SELECTOR_SEARCH_DIRECTION_ANCESTOR.bits();\n }\n}\n\nimpl ElementSelectorFlags {\n /// Returns the subset of flags that apply to the element.\n pub fn for_self(self) -> ElementSelectorFlags {\n self & (ElementSelectorFlags::HAS_EMPTY_SELECTOR\n | ElementSelectorFlags::ANCHORS_RELATIVE_SELECTOR\n | ElementSelectorFlags::ANCHORS_RELATIVE_SELECTOR_NON_SUBJECT\n | ElementSelectorFlags::RELATIVE_SELECTOR_SEARCH_DIRECTION_SIBLING\n | ElementSelectorFlags::RELATIVE_SELECTOR_SEARCH_DIRECTION_ANCESTOR)\n }\n\n /// Returns the subset of flags that apply to the parent.\n pub fn for_parent(self) -> ElementSelectorFlags {\n self & (ElementSelectorFlags::HAS_SLOW_SELECTOR\n | ElementSelectorFlags::HAS_SLOW_SELECTOR_LATER_SIBLINGS\n | ElementSelectorFlags::HAS_SLOW_SELECTOR_NTH\n | ElementSelectorFlags::HAS_SLOW_SELECTOR_NTH_OF\n | ElementSelectorFlags::HAS_EDGE_CHILD_SELECTOR)\n }\n}\n\n/// Holds per-compound-selector data.\nstruct LocalMatchingContext<'a, 'b: 'a, Impl: SelectorImpl> {\n shared: &'a mut MatchingContext<'b, Impl>,\n rightmost: SubjectOrPseudoElement,\n quirks_data: Option>,\n}\n\n#[inline(always)]\npub fn matches_selector_list(\n selector_list: &SelectorList,\n element: &E,\n context: &mut MatchingContext,\n) -> bool\nwhere\n E: Element,\n{\n // This is pretty much any(..) but manually inlined because the compiler\n // refuses to do so from querySelector / querySelectorAll.\n for selector in selector_list.slice() {\n let matches = matches_selector(selector, 0, None, element, context);\n if matches {\n return true;\n }\n }\n\n false\n}\n\n/// Given the ancestor hashes from a selector, see if the current element,\n/// represented by the bloom filter, has a chance of matching at all.\n#[inline(always)]\npub fn selector_may_match(hashes: &AncestorHashes, bf: &BloomFilter) -> bool {\n // Check the first three hashes. Note that we can check for zero before\n // masking off the high bits, since if any of the first three hashes is\n // zero the fourth will be as well. We also take care to avoid the\n // special-case complexity of the fourth hash until we actually reach it,\n // because we usually don't.\n //\n // To be clear: this is all extremely hot.\n for i in 0..3 {\n let packed = hashes.packed_hashes[i];\n if packed == 0 {\n // No more hashes left - unable to fast-reject.\n return true;\n }\n\n if !bf.might_contain_hash(packed & BLOOM_HASH_MASK) {\n // Hooray! We fast-rejected on this hash.\n return false;\n }\n }\n\n // Now do the slighty-more-complex work of synthesizing the fourth hash,\n // and check it against the filter if it exists.\n let fourth = hashes.fourth_hash();\n fourth == 0 || bf.might_contain_hash(fourth)\n}\n\n/// A result of selector matching, includes 3 failure types,\n///\n/// NotMatchedAndRestartFromClosestLaterSibling\n/// NotMatchedAndRestartFromClosestDescendant\n/// NotMatchedGlobally\n///\n/// When NotMatchedGlobally appears, stop selector matching completely since\n/// the succeeding selectors never matches.\n/// It is raised when\n/// Child combinator cannot find the candidate element.\n/// Descendant combinator cannot find the candidate element.\n///\n/// When NotMatchedAndRestartFromClosestDescendant appears, the selector\n/// matching does backtracking and restarts from the closest Descendant\n/// combinator.\n/// It is raised when\n/// NextSibling combinator cannot find the candidate element.\n/// LaterSibling combinator cannot find the candidate element.\n/// Child combinator doesn't match on the found element.\n///\n/// When NotMatchedAndRestartFromClosestLaterSibling appears, the selector\n/// matching does backtracking and restarts from the closest LaterSibling\n/// combinator.\n/// It is raised when\n/// NextSibling combinator doesn't match on the found element.\n///\n/// For example, when the selector \"d1 d2 a\" is provided and we cannot *find*\n/// an appropriate ancestor element for \"d1\", this selector matching raises\n/// NotMatchedGlobally since even if \"d2\" is moved to more upper element, the\n/// candidates for \"d1\" becomes less than before and d1 .\n///\n/// The next example is siblings. When the selector \"b1 + b2 ~ d1 a\" is\n/// provided and we cannot *find* an appropriate brother element for b1,\n/// the selector matching raises NotMatchedAndRestartFromClosestDescendant.\n/// The selectors (\"b1 + b2 ~\") doesn't match and matching restart from \"d1\".\n///\n/// The additional example is child and sibling. When the selector\n/// \"b1 + c1 > b2 ~ d1 a\" is provided and the selector \"b1\" doesn't match on\n/// the element, this \"b1\" raises NotMatchedAndRestartFromClosestLaterSibling.\n/// However since the selector \"c1\" raises\n/// NotMatchedAndRestartFromClosestDescendant. So the selector\n/// \"b1 + c1 > b2 ~ \" doesn't match and restart matching from \"d1\".\n///\n/// There is also the unknown result, which is used during invalidation when\n/// specific selector is being tested for before/after comparison. More specifically,\n/// selectors that are too expensive to correctly compute during invalidation may\n/// return unknown, as the computation will be thrown away and only to be recomputed\n/// during styling. For most cases, the unknown result can be treated as matching.\n/// This is because a compound of selectors acts like &&, and unknown && matched\n/// == matched and unknown && not-matched == not-matched. However, some selectors,\n/// like `:is()`, behave like || i.e. `:is(.a, .b)` == a || b. Treating unknown\n/// == matching then causes these selectors to always return matching, which undesired\n/// for before/after comparison. Coercing to not-matched doesn't work since each\n/// inner selector may have compounds: e.g. Toggling `.foo` in `:is(.foo:has(..))`\n/// with coersion to not-matched would result in an invalid before/after comparison\n/// of not-matched/not-matched.\n#[derive(Clone, Copy, Eq, PartialEq)]\nenum SelectorMatchingResult {\n Matched,\n NotMatchedAndRestartFromClosestLaterSibling,\n NotMatchedAndRestartFromClosestDescendant,\n NotMatchedGlobally,\n Unknown,\n}\n\nimpl From for KleeneValue {\n #[inline]\n fn from(value: SelectorMatchingResult) -> Self {\n match value {\n SelectorMatchingResult::Matched => KleeneValue::True,\n SelectorMatchingResult::Unknown => KleeneValue::Unknown,\n SelectorMatchingResult::NotMatchedAndRestartFromClosestLaterSibling\n | SelectorMatchingResult::NotMatchedAndRestartFromClosestDescendant\n | SelectorMatchingResult::NotMatchedGlobally => KleeneValue::False,\n }\n }\n}\n\n/// Matches a selector, fast-rejecting against a bloom filter.\n///\n/// We accept an offset to allow consumers to represent and match against\n/// partial selectors (indexed from the right). We use this API design, rather\n/// than having the callers pass a SelectorIter, because creating a SelectorIter\n/// requires dereferencing the selector to get the length, which adds an\n/// unnecessary cache miss for cases when we can fast-reject with AncestorHashes\n/// (which the caller can store inline with the selector pointer).\n#[inline(always)]\npub fn matches_selector(\n selector: &Selector,\n offset: usize,\n hashes: Option<&AncestorHashes>,\n element: &E,\n context: &mut MatchingContext,\n) -> bool\nwhere\n E: Element,\n{\n let result = matches_selector_kleene(selector, offset, hashes, element, context);\n if cfg!(debug_assertions) && result == KleeneValue::Unknown {\n debug_assert!(\n context\n .matching_for_invalidation_comparison()\n .unwrap_or(false),\n \"How did we return unknown?\"\n );\n }\n result.to_bool(true)\n}\n\n/// Same as matches_selector, but returns the Kleene value as-is.\n#[inline(always)]\npub fn matches_selector_kleene(\n selector: &Selector,\n offset: usize,\n hashes: Option<&AncestorHashes>,\n element: &E,\n context: &mut MatchingContext,\n) -> KleeneValue\nwhere\n E: Element,\n{\n // Use the bloom filter to fast-reject.\n if let Some(hashes) = hashes {\n if let Some(filter) = context.bloom_filter {\n if !selector_may_match(hashes, filter) {\n return KleeneValue::False;\n }\n }\n }\n matches_complex_selector(\n selector.iter_from(offset),\n element,\n context,\n if selector.is_rightmost(offset) {\n SubjectOrPseudoElement::Yes\n } else {\n SubjectOrPseudoElement::No\n },\n )\n}\n\n/// Whether a compound selector matched, and whether it was the rightmost\n/// selector inside the complex selector.\npub enum CompoundSelectorMatchingResult {\n /// The selector was fully matched.\n FullyMatched,\n /// The compound selector matched, and the next combinator offset is\n /// `next_combinator_offset`.\n Matched { next_combinator_offset: usize },\n /// The selector didn't match.\n NotMatched,\n}\n\nfn complex_selector_early_reject_by_local_name(\n list: &SelectorList,\n element: &E,\n) -> bool {\n list.slice()\n .iter()\n .all(|s| early_reject_by_local_name(s, 0, element))\n}\n\n/// Returns true if this compound would not match the given element by due\n/// to a local name selector (If one exists).\npub fn early_reject_by_local_name(\n selector: &Selector,\n from_offset: usize,\n element: &E,\n) -> bool {\n let iter = selector.iter_from(from_offset);\n for component in iter {\n if match component {\n Component::LocalName(name) => !matches_local_name(element, name),\n Component::Is(list) | Component::Where(list) => {\n complex_selector_early_reject_by_local_name(list, element)\n },\n _ => continue,\n } {\n return true;\n }\n }\n false\n}\n\n/// Matches a compound selector belonging to `selector`, starting at offset\n/// `from_offset`, matching left to right.\n///\n/// Requires that `from_offset` points to a `Combinator`.\n///\n/// NOTE(emilio): This doesn't allow to match in the leftmost sequence of the\n/// complex selector, but it happens to be the case we don't need it.\npub fn matches_compound_selector_from(\n selector: &Selector,\n mut from_offset: usize,\n context: &mut MatchingContext,\n element: &E,\n) -> CompoundSelectorMatchingResult\nwhere\n E: Element,\n{\n debug_assert!(\n !context\n .matching_for_invalidation_comparison()\n .unwrap_or(false),\n \"CompoundSelectorMatchingResult doesn't support unknown\"\n );\n if cfg!(debug_assertions) && from_offset != 0 {\n selector.combinator_at_parse_order(from_offset - 1); // This asserts.\n }\n\n let mut local_context = LocalMatchingContext {\n shared: context,\n // We have no info if this is an outer selector. This function is called in\n // an invalidation context, which only calls this for non-subject (i.e.\n // Non-rightmost) positions.\n rightmost: SubjectOrPseudoElement::No,\n quirks_data: None,\n };\n\n // Find the end of the selector or the next combinator, then match\n // backwards, so that we match in the same order as\n // matches_complex_selector, which is usually faster.\n let start_offset = from_offset;\n for component in selector.iter_raw_parse_order_from(from_offset) {\n if matches!(*component, Component::Combinator(..)) {\n debug_assert_ne!(from_offset, 0, \"Selector started with a combinator?\");\n break;\n }\n\n from_offset += 1;\n }\n\n debug_assert!(from_offset >= 1);\n debug_assert!(from_offset <= selector.len());\n\n let iter = selector.iter_from(selector.len() - from_offset);\n debug_assert!(\n iter.clone().next().is_some() || from_offset != selector.len(),\n \"Got the math wrong: {:?} | {:?} | {} {}\",\n selector,\n selector.iter_raw_match_order().as_slice(),\n from_offset,\n start_offset\n );\n\n debug_assert!(\n !local_context.shared.featureless(),\n \"Invalidating featureless element somehow?\"\n );\n\n for component in iter {\n let result = matches_simple_selector(component, element, &mut local_context);\n debug_assert!(\n result != KleeneValue::Unknown,\n \"Returned unknown in non invalidation context?\"\n );\n if !result.to_bool(true) {\n return CompoundSelectorMatchingResult::NotMatched;\n }\n }\n\n if from_offset != selector.len() {\n return CompoundSelectorMatchingResult::Matched {\n next_combinator_offset: from_offset,\n };\n }\n\n CompoundSelectorMatchingResult::FullyMatched\n}\n\n/// Matches a complex selector.\n#[inline(always)]\nfn matches_complex_selector(\n mut iter: SelectorIter,\n element: &E,\n context: &mut MatchingContext,\n rightmost: SubjectOrPseudoElement,\n) -> KleeneValue\nwhere\n E: Element,\n{\n // If this is the special pseudo-element mode, consume the ::pseudo-element\n // before proceeding, since the caller has already handled that part.\n if context.matching_mode() == MatchingMode::ForStatelessPseudoElement && !context.is_nested() {\n // Consume the pseudo.\n match *iter.next().unwrap() {\n Component::PseudoElement(ref pseudo) => {\n if let Some(ref f) = context.pseudo_element_matching_fn {\n if !f(pseudo) {\n return KleeneValue::False;\n }\n }\n },\n ref other => {\n debug_assert!(\n false,\n \"Used MatchingMode::ForStatelessPseudoElement \\\n in a non-pseudo selector {:?}\",\n other\n );\n return KleeneValue::False;\n },\n }\n\n if !iter.matches_for_stateless_pseudo_element() {\n return KleeneValue::False;\n }\n\n // Advance to the non-pseudo-element part of the selector.\n let next_sequence = iter.next_sequence().unwrap();\n debug_assert_eq!(next_sequence, Combinator::PseudoElement);\n }\n\n matches_complex_selector_internal(\n iter,\n element,\n context,\n rightmost,\n SubjectOrPseudoElement::Yes,\n )\n .into()\n}\n\n/// Matches each selector of a list as a complex selector\nfn matches_complex_selector_list(\n list: &[Selector],\n element: &E,\n context: &mut MatchingContext,\n rightmost: SubjectOrPseudoElement,\n) -> KleeneValue {\n KleeneValue::any(list.iter(), |selector| {\n matches_complex_selector(selector.iter(), element, context, rightmost)\n })\n}\n\nfn matches_relative_selector(\n relative_selector: &RelativeSelector,\n element: &E,\n context: &mut MatchingContext,\n rightmost: SubjectOrPseudoElement,\n) -> bool {\n // Overall, we want to mark the path that we've traversed so that when an element\n // is invalidated, we early-reject unnecessary relative selector invalidations.\n if relative_selector.match_hint.is_descendant_direction() {\n if context.needs_selector_flags() {\n element.apply_selector_flags(\n ElementSelectorFlags::RELATIVE_SELECTOR_SEARCH_DIRECTION_ANCESTOR,\n );\n }\n let mut next_element = element.first_element_child();\n while let Some(el) = next_element {\n if context.needs_selector_flags() {\n el.apply_selector_flags(\n ElementSelectorFlags::RELATIVE_SELECTOR_SEARCH_DIRECTION_ANCESTOR,\n );\n }\n let mut matched = matches_complex_selector(\n relative_selector.selector.iter(),\n &el,\n context,\n rightmost,\n )\n .to_bool(true);\n if !matched && relative_selector.match_hint.is_subtree() {\n matched = matches_relative_selector_subtree(\n &relative_selector.selector,\n &el,\n context,\n rightmost,\n );\n }\n if matched {\n return true;\n }\n next_element = el.next_sibling_element();\n }\n } else {\n debug_assert!(\n matches!(\n relative_selector.match_hint,\n RelativeSelectorMatchHint::InNextSibling\n | RelativeSelectorMatchHint::InNextSiblingSubtree\n | RelativeSelectorMatchHint::InSibling\n | RelativeSelectorMatchHint::InSiblingSubtree\n ),\n \"Not descendant direction, but also not sibling direction?\"\n );\n if context.needs_selector_flags() {\n element.apply_selector_flags(\n ElementSelectorFlags::RELATIVE_SELECTOR_SEARCH_DIRECTION_SIBLING,\n );\n }\n let sibling_flag = if relative_selector.match_hint.is_subtree() {\n ElementSelectorFlags::RELATIVE_SELECTOR_SEARCH_DIRECTION_ANCESTOR_SIBLING\n } else {\n ElementSelectorFlags::RELATIVE_SELECTOR_SEARCH_DIRECTION_SIBLING\n };\n let mut next_element = element.next_sibling_element();\n while let Some(el) = next_element {\n if context.needs_selector_flags() {\n el.apply_selector_flags(sibling_flag);\n }\n let matched = if relative_selector.match_hint.is_subtree() {\n matches_relative_selector_subtree(\n &relative_selector.selector,\n &el,\n context,\n rightmost,\n )\n } else {\n matches_complex_selector(relative_selector.selector.iter(), &el, context, rightmost)\n .to_bool(true)\n };\n if matched {\n return true;\n }\n if relative_selector.match_hint.is_next_sibling() {\n break;\n }\n next_element = el.next_sibling_element();\n }\n }\n return false;\n}\n\nfn relative_selector_match_early(\n selector: &RelativeSelector,\n element: &E,\n context: &mut MatchingContext,\n) -> Option {\n // See if we can return a cached result.\n if let Some(cached) = context\n .selector_caches\n .relative_selector\n .lookup(element.opaque(), selector)\n {\n return Some(cached.matched());\n }\n // See if we can fast-reject.\n if context\n .selector_caches\n .relative_selector_filter_map\n .fast_reject(element, selector, context.quirks_mode())\n {\n // Alright, add as unmatched to cache.\n context.selector_caches.relative_selector.add(\n element.opaque(),\n selector,\n RelativeSelectorCachedMatch::NotMatched,\n );\n return Some(false);\n }\n None\n}\n\nfn match_relative_selectors(\n selectors: &[RelativeSelector],\n element: &E,\n context: &mut MatchingContext,\n rightmost: SubjectOrPseudoElement,\n) -> KleeneValue {\n if context.relative_selector_anchor().is_some() {\n // FIXME(emilio): This currently can happen with nesting, and it's not fully\n // correct, arguably. But the ideal solution isn't super-clear either. For now,\n // cope with it and explicitly reject it at match time. See [1] for discussion.\n //\n // [1]: https://github.com/w3c/csswg-drafts/issues/9600\n return KleeneValue::False;\n }\n if let Some(may_return_unknown) = context.matching_for_invalidation_comparison() {\n // In the context of invalidation, :has is expensive, especially because we\n // can't use caching/filtering due to now/then matches. DOM structure also\n // may have changed.\n return if may_return_unknown {\n KleeneValue::Unknown\n } else {\n KleeneValue::from(!context.in_negation())\n };\n }\n context\n .nest_for_relative_selector(element.opaque(), |context| {\n do_match_relative_selectors(selectors, element, context, rightmost)\n })\n .into()\n}\n\n/// Matches a relative selector in a list of relative selectors.\nfn do_match_relative_selectors(\n selectors: &[RelativeSelector],\n element: &E,\n context: &mut MatchingContext,\n rightmost: SubjectOrPseudoElement,\n) -> bool {\n // Due to style sharing implications (See style sharing code), we mark the current styling context\n // to mark elements considered for :has matching. Additionally, we want to mark the elements themselves,\n // since we don't want to indiscriminately invalidate every element as a potential anchor.\n if rightmost == SubjectOrPseudoElement::Yes {\n if context.needs_selector_flags() {\n element.apply_selector_flags(ElementSelectorFlags::ANCHORS_RELATIVE_SELECTOR);\n }\n } else {\n if context.needs_selector_flags() {\n element\n .apply_selector_flags(ElementSelectorFlags::ANCHORS_RELATIVE_SELECTOR_NON_SUBJECT);\n }\n }\n\n for relative_selector in selectors.iter() {\n if let Some(result) = relative_selector_match_early(relative_selector, element, context) {\n if result {\n return true;\n }\n // Early return indicates no match, continue to next selector.\n continue;\n }\n\n let matched = matches_relative_selector(relative_selector, element, context, rightmost);\n context.selector_caches.relative_selector.add(\n element.opaque(),\n relative_selector,\n if matched {\n RelativeSelectorCachedMatch::Matched\n } else {\n RelativeSelectorCachedMatch::NotMatched\n },\n );\n if matched {\n return true;\n }\n }\n\n false\n}\n\nfn matches_relative_selector_subtree(\n selector: &Selector,\n element: &E,\n context: &mut MatchingContext,\n rightmost: SubjectOrPseudoElement,\n) -> bool {\n let mut current = element.first_element_child();\n\n while let Some(el) = current {\n if context.needs_selector_flags() {\n el.apply_selector_flags(\n ElementSelectorFlags::RELATIVE_SELECTOR_SEARCH_DIRECTION_ANCESTOR,\n );\n }\n if matches_complex_selector(selector.iter(), &el, context, rightmost).to_bool(true) {\n return true;\n }\n\n if matches_relative_selector_subtree(selector, &el, context, rightmost) {\n return true;\n }\n\n current = el.next_sibling_element();\n }\n\n false\n}\n\n/// Whether the :hover and :active quirk applies.\n///\n/// https://quirks.spec.whatwg.org/#the-active-and-hover-quirk\nfn hover_and_active_quirk_applies(\n selector_iter: &SelectorIter,\n context: &MatchingContext,\n rightmost: SubjectOrPseudoElement,\n) -> bool {\n debug_assert_eq!(context.quirks_mode(), QuirksMode::Quirks);\n\n if context.is_nested() {\n return false;\n }\n\n // This compound selector had a pseudo-element to the right that we\n // intentionally skipped.\n if rightmost == SubjectOrPseudoElement::Yes\n && context.matching_mode() == MatchingMode::ForStatelessPseudoElement\n {\n return false;\n }\n\n selector_iter.clone().all(|simple| match *simple {\n Component::NonTSPseudoClass(ref pseudo_class) => pseudo_class.is_active_or_hover(),\n _ => false,\n })\n}\n\n#[derive(Clone, Copy, PartialEq)]\nenum SubjectOrPseudoElement {\n Yes,\n No,\n}\n\nfn host_for_part(element: &E, context: &MatchingContext) -> Option\nwhere\n E: Element,\n{\n let scope = context.current_host;\n let mut curr = element.containing_shadow_host()?;\n if scope == Some(curr.opaque()) {\n return Some(curr);\n }\n loop {\n let parent = curr.containing_shadow_host();\n if parent.as_ref().map(|h| h.opaque()) == scope {\n return Some(curr);\n }\n curr = parent?;\n }\n}\n\nfn assigned_slot(element: &E, context: &MatchingContext) -> Option\nwhere\n E: Element,\n{\n debug_assert!(element\n .assigned_slot()\n .map_or(true, |s| s.is_html_slot_element()));\n let scope = context.current_host?;\n let mut current_slot = element.assigned_slot()?;\n while current_slot.containing_shadow_host().unwrap().opaque() != scope {\n current_slot = current_slot.assigned_slot()?;\n }\n Some(current_slot)\n}\n\nstruct NextElement {\n next_element: Option,\n featureless: bool,\n}\n\nimpl NextElement {\n #[inline(always)]\n fn new(next_element: Option, featureless: bool) -> Self {\n Self {\n next_element,\n featureless,\n }\n }\n}\n\n#[inline(always)]\nfn next_element_for_combinator(\n element: &E,\n combinator: Combinator,\n context: &MatchingContext,\n) -> NextElement\nwhere\n E: Element,\n{\n match combinator {\n Combinator::NextSibling | Combinator::LaterSibling => {\n NextElement::new(element.prev_sibling_element(), false)\n },\n Combinator::Child | Combinator::Descendant => {\n if let Some(parent) = element.parent_element() {\n return NextElement::new(Some(parent), false);\n }\n\n let element = if element.parent_node_is_shadow_root() {\n element.containing_shadow_host()\n } else {\n None\n };\n NextElement::new(element, true)\n },\n Combinator::Part => NextElement::new(host_for_part(element, context), false),\n Combinator::SlotAssignment => NextElement::new(assigned_slot(element, context), false),\n Combinator::PseudoElement => {\n NextElement::new(element.pseudo_element_originating_element(), false)\n },\n }\n}\n\nfn matches_complex_selector_internal(\n mut selector_iter: SelectorIter,\n element: &E,\n context: &mut MatchingContext,\n mut rightmost: SubjectOrPseudoElement,\n mut first_subject_compound: SubjectOrPseudoElement,\n) -> SelectorMatchingResult\nwhere\n E: Element,\n{\n debug!(\n \"Matching complex selector {:?} for {:?}\",\n selector_iter, element\n );\n\n let matches_compound_selector =\n matches_compound_selector(&mut selector_iter, element, context, rightmost);\n\n let Some(combinator) = selector_iter.next_sequence() else {\n return match matches_compound_selector {\n KleeneValue::True => SelectorMatchingResult::Matched,\n KleeneValue::Unknown => SelectorMatchingResult::Unknown,\n KleeneValue::False => {\n SelectorMatchingResult::NotMatchedAndRestartFromClosestLaterSibling\n },\n };\n };\n\n let is_pseudo_combinator = combinator.is_pseudo_element();\n if context.featureless() && !is_pseudo_combinator {\n // A featureless element shouldn't match any further combinator.\n // TODO(emilio): Maybe we could avoid the compound matching more eagerly.\n return SelectorMatchingResult::NotMatchedGlobally;\n }\n\n let is_sibling_combinator = combinator.is_sibling();\n if is_sibling_combinator && context.needs_selector_flags() {\n // We need the flags even if we don't match.\n element.apply_selector_flags(ElementSelectorFlags::HAS_SLOW_SELECTOR_LATER_SIBLINGS);\n }\n\n if matches_compound_selector == KleeneValue::False {\n // We don't short circuit unknown here, since the rest of the selector\n // to the left of this compound may still return false.\n return SelectorMatchingResult::NotMatchedAndRestartFromClosestLaterSibling;\n }\n\n if !is_pseudo_combinator {\n rightmost = SubjectOrPseudoElement::No;\n first_subject_compound = SubjectOrPseudoElement::No;\n }\n\n // Stop matching :visited as soon as we find a link, or a combinator for\n // something that isn't an ancestor.\n let mut visited_handling = if is_sibling_combinator {\n VisitedHandlingMode::AllLinksUnvisited\n } else {\n context.visited_handling()\n };\n\n let candidate_not_found = if is_sibling_combinator {\n SelectorMatchingResult::NotMatchedAndRestartFromClosestDescendant\n } else {\n SelectorMatchingResult::NotMatchedGlobally\n };\n\n let mut element = element.clone();\n loop {\n if element.is_link() {\n visited_handling = VisitedHandlingMode::AllLinksUnvisited;\n }\n\n let NextElement {\n next_element,\n featureless,\n } = next_element_for_combinator(&element, combinator, &context);\n element = match next_element {\n None => return candidate_not_found,\n Some(e) => e,\n };\n\n let result = context.with_visited_handling_mode(visited_handling, |context| {\n context.with_featureless(featureless, |context| {\n matches_complex_selector_internal(\n selector_iter.clone(),\n &element,\n context,\n rightmost,\n first_subject_compound,\n )\n })\n });\n\n // Return the status immediately if it is one of the global states.\n match result {\n SelectorMatchingResult::Matched => {\n debug_assert!(\n matches_compound_selector.to_bool(true),\n \"Compound didn't match?\"\n );\n if !matches_compound_selector.to_bool(false) {\n return SelectorMatchingResult::Unknown;\n }\n return result;\n },\n SelectorMatchingResult::Unknown | SelectorMatchingResult::NotMatchedGlobally => {\n return result\n },\n _ => {},\n }\n\n match combinator {\n Combinator::Descendant => {\n // The Descendant combinator and the status is\n // NotMatchedAndRestartFromClosestLaterSibling or\n // NotMatchedAndRestartFromClosestDescendant, or the LaterSibling combinator and\n // the status is NotMatchedAndRestartFromClosestDescendant, we can continue to\n // matching on the next candidate element.\n },\n Combinator::Child => {\n // Upgrade the failure status to NotMatchedAndRestartFromClosestDescendant.\n return SelectorMatchingResult::NotMatchedAndRestartFromClosestDescendant;\n },\n Combinator::LaterSibling => {\n // If the failure status is NotMatchedAndRestartFromClosestDescendant and combinator is\n // LaterSibling, give up this LaterSibling matching and restart from the closest\n // descendant combinator.\n if matches!(\n result,\n SelectorMatchingResult::NotMatchedAndRestartFromClosestDescendant\n ) {\n return result;\n }\n },\n Combinator::NextSibling\n | Combinator::PseudoElement\n | Combinator::Part\n | Combinator::SlotAssignment => {\n // NOTE(emilio): Conceptually, PseudoElement / Part / SlotAssignment should return\n // `candidate_not_found`, but it doesn't matter in practice since they don't have\n // sibling / descendant combinators to the right of them. This hopefully saves one\n // branch.\n return result;\n },\n }\n\n if featureless {\n // A featureless element didn't match the selector, we can stop matching now rather\n // than looking at following elements for our combinator.\n return candidate_not_found;\n }\n }\n}\n\n#[inline]\nfn matches_local_name(element: &E, local_name: &LocalName) -> bool\nwhere\n E: Element,\n{\n let name = select_name(element, &local_name.name, &local_name.lower_name).borrow();\n element.has_local_name(name)\n}\n\nfn matches_part(\n element: &E,\n parts: &[::Identifier],\n context: &mut MatchingContext,\n) -> bool\nwhere\n E: Element,\n{\n let mut hosts = SmallVec::<[E; 4]>::new();\n\n let mut host = match element.containing_shadow_host() {\n Some(h) => h,\n None => return false,\n };\n\n let current_host = context.current_host;\n if current_host != Some(host.opaque()) {\n loop {\n let outer_host = host.containing_shadow_host();\n if outer_host.as_ref().map(|h| h.opaque()) == current_host {\n break;\n }\n let outer_host = match outer_host {\n Some(h) => h,\n None => return false,\n };\n // TODO(emilio): if worth it, we could early return if\n // host doesn't have the exportparts attribute.\n hosts.push(host);\n host = outer_host;\n }\n }\n\n // Translate the part into the right scope.\n parts.iter().all(|part| {\n let mut part = part.clone();\n for host in hosts.iter().rev() {\n part = match host.imported_part(&part) {\n Some(p) => p,\n None => return false,\n };\n }\n element.is_part(&part)\n })\n}\n\nfn matches_host(\n element: &E,\n selector: Option<&Selector>,\n context: &mut MatchingContext,\n rightmost: SubjectOrPseudoElement,\n) -> KleeneValue\nwhere\n E: Element,\n{\n let host = match context.shadow_host() {\n Some(h) => h,\n None => return KleeneValue::False,\n };\n if host != element.opaque() {\n return KleeneValue::False;\n }\n let Some(selector) = selector else {\n return KleeneValue::True;\n };\n context.nest(|context| {\n context.with_featureless(false, |context| {\n matches_complex_selector(selector.iter(), element, context, rightmost)\n })\n })\n}\n\nfn matches_slotted(\n element: &E,\n selector: &Selector,\n context: &mut MatchingContext,\n rightmost: SubjectOrPseudoElement,\n) -> KleeneValue\nwhere\n E: Element,\n{\n // are never flattened tree slottables.\n if element.is_html_slot_element() {\n return KleeneValue::False;\n }\n context.nest(|context| matches_complex_selector(selector.iter(), element, context, rightmost))\n}\n\nfn matches_rare_attribute_selector(\n element: &E,\n attr_sel: &AttrSelectorWithOptionalNamespace,\n) -> bool\nwhere\n E: Element,\n{\n let empty_string;\n let namespace = match attr_sel.namespace() {\n Some(ns) => ns,\n None => {\n empty_string = crate::parser::namespace_empty_string::();\n NamespaceConstraint::Specific(&empty_string)\n },\n };\n element.attr_matches(\n &namespace,\n select_name(element, &attr_sel.local_name, &attr_sel.local_name_lower),\n &match attr_sel.operation {\n ParsedAttrSelectorOperation::Exists => AttrSelectorOperation::Exists,\n ParsedAttrSelectorOperation::WithValue {\n operator,\n case_sensitivity,\n ref value,\n } => AttrSelectorOperation::WithValue {\n operator,\n case_sensitivity: to_unconditional_case_sensitivity(case_sensitivity, element),\n value,\n },\n },\n )\n}\n\n/// There are relatively few selectors in a given compound that may match a featureless element.\n/// Instead of adding a check to every selector that may not match, we handle it here in an out of\n/// line path.\npub(crate) fn compound_matches_featureless_host(\n iter: &mut SelectorIter,\n scope_matches_featureless_host: bool,\n) -> MatchesFeaturelessHost {\n let mut matches = MatchesFeaturelessHost::Only;\n for component in iter {\n match component {\n Component::Scope | Component::ImplicitScope if scope_matches_featureless_host => {},\n // :host only matches featureless elements.\n Component::Host(..) => {},\n // Pseudo-elements are allowed to match as well.\n Component::PseudoElement(..) => {},\n // We allow logical pseudo-classes, but we'll fail matching of the inner selectors if\n // necessary.\n Component::Is(ref l) | Component::Where(ref l) => {\n let mut any_yes = false;\n let mut any_no = false;\n for selector in l.slice() {\n match selector.matches_featureless_host(scope_matches_featureless_host) {\n MatchesFeaturelessHost::Never => {\n any_no = true;\n },\n MatchesFeaturelessHost::Yes => {\n any_yes = true;\n any_no = true;\n },\n MatchesFeaturelessHost::Only => {\n any_yes = true;\n },\n }\n }\n if !any_yes {\n return MatchesFeaturelessHost::Never;\n }\n if any_no {\n // Potentially downgrade since we might match non-featureless elements too.\n matches = MatchesFeaturelessHost::Yes;\n }\n },\n Component::Negation(ref l) => {\n // For now preserving behavior, see\n // https://github.com/w3c/csswg-drafts/issues/10179 for existing resolutions that\n // tweak this behavior.\n for selector in l.slice() {\n if selector.matches_featureless_host(scope_matches_featureless_host)\n != MatchesFeaturelessHost::Only\n {\n return MatchesFeaturelessHost::Never;\n }\n }\n },\n // Other components don't match the host scope.\n _ => return MatchesFeaturelessHost::Never,\n }\n }\n matches\n}\n\n/// Determines whether the given element matches the given compound selector.\n#[inline]\nfn matches_compound_selector(\n selector_iter: &mut SelectorIter,\n element: &E,\n context: &mut MatchingContext,\n rightmost: SubjectOrPseudoElement,\n) -> KleeneValue\nwhere\n E: Element,\n{\n if context.featureless()\n && compound_matches_featureless_host(\n &mut selector_iter.clone(),\n /* scope_matches_featureless_host = */ true,\n ) == MatchesFeaturelessHost::Never\n {\n return KleeneValue::False;\n }\n let quirks_data = if context.quirks_mode() == QuirksMode::Quirks {\n Some(selector_iter.clone())\n } else {\n None\n };\n let mut local_context = LocalMatchingContext {\n shared: context,\n rightmost,\n quirks_data,\n };\n KleeneValue::any_false(selector_iter, |simple| {\n matches_simple_selector(simple, element, &mut local_context)\n })\n}\n\n/// Determines whether the given element matches the given single selector.\nfn matches_simple_selector(\n selector: &Component,\n element: &E,\n context: &mut LocalMatchingContext,\n) -> KleeneValue\nwhere\n E: Element,\n{\n debug_assert!(context.shared.is_nested() || !context.shared.in_negation());\n let rightmost = context.rightmost;\n KleeneValue::from(match *selector {\n Component::ID(ref id) => {\n element.has_id(id, context.shared.classes_and_ids_case_sensitivity())\n },\n Component::Class(ref class) => {\n element.has_class(class, context.shared.classes_and_ids_case_sensitivity())\n },\n Component::LocalName(ref local_name) => matches_local_name(element, local_name),\n Component::AttributeInNoNamespaceExists {\n ref local_name,\n ref local_name_lower,\n } => element.has_attr_in_no_namespace(select_name(element, local_name, local_name_lower)),\n Component::AttributeInNoNamespace {\n ref local_name,\n ref value,\n operator,\n case_sensitivity,\n } => element.attr_matches(\n &NamespaceConstraint::Specific(&crate::parser::namespace_empty_string::()),\n local_name,\n &AttrSelectorOperation::WithValue {\n operator,\n case_sensitivity: to_unconditional_case_sensitivity(case_sensitivity, element),\n value,\n },\n ),\n Component::AttributeOther(ref attr_sel) => {\n matches_rare_attribute_selector(element, attr_sel)\n },\n Component::Part(ref parts) => matches_part(element, parts, &mut context.shared),\n Component::Slotted(ref selector) => {\n return matches_slotted(element, selector, &mut context.shared, rightmost);\n },\n Component::PseudoElement(ref pseudo) => {\n element.match_pseudo_element(pseudo, context.shared)\n },\n Component::ExplicitUniversalType | Component::ExplicitAnyNamespace => true,\n Component::Namespace(_, ref url) | Component::DefaultNamespace(ref url) => {\n element.has_namespace(&url.borrow())\n },\n Component::ExplicitNoNamespace => {\n let ns = crate::parser::namespace_empty_string::();\n element.has_namespace(&ns.borrow())\n },\n Component::NonTSPseudoClass(ref pc) => {\n if let Some(ref iter) = context.quirks_data {\n if pc.is_active_or_hover()\n && !element.is_link()\n && hover_and_active_quirk_applies(iter, context.shared, context.rightmost)\n {\n return KleeneValue::False;\n }\n }\n element.match_non_ts_pseudo_class(pc, &mut context.shared)\n },\n Component::Root => element.is_root(),\n Component::Empty => {\n if context.shared.needs_selector_flags() {\n element.apply_selector_flags(ElementSelectorFlags::HAS_EMPTY_SELECTOR);\n }\n element.is_empty()\n },\n Component::Host(ref selector) => {\n return matches_host(element, selector.as_ref(), &mut context.shared, rightmost);\n },\n Component::ParentSelector => match context.shared.scope_element {\n Some(ref scope_element) => element.opaque() == *scope_element,\n None => element.is_root(),\n },\n Component::Scope | Component::ImplicitScope => {\n let matching_for_invalidation = context.shared.matching_for_invalidation_comparison();\n if context.shared.matching_for_revalidation() || matching_for_invalidation.is_some() {\n let may_return_unknown = matching_for_invalidation.unwrap_or(false);\n return if may_return_unknown {\n KleeneValue::Unknown\n } else {\n KleeneValue::from(!context.shared.in_negation())\n };\n }\n match context.shared.scope_element {\n Some(ref scope_element) => element.opaque() == *scope_element,\n None => element.is_root(),\n }\n },\n Component::Nth(ref nth_data) => {\n return matches_generic_nth_child(element, context.shared, nth_data, &[], rightmost);\n },\n Component::NthOf(ref nth_of_data) => {\n return context.shared.nest(|context| {\n matches_generic_nth_child(\n element,\n context,\n nth_of_data.nth_data(),\n nth_of_data.selectors(),\n rightmost,\n )\n })\n },\n Component::Is(ref list) | Component::Where(ref list) => {\n return context.shared.nest(|context| {\n matches_complex_selector_list(list.slice(), element, context, rightmost)\n })\n },\n Component::Negation(ref list) => {\n return context.shared.nest_for_negation(|context| {\n !matches_complex_selector_list(list.slice(), element, context, rightmost)\n })\n },\n Component::Has(ref relative_selectors) => {\n return match_relative_selectors(\n relative_selectors,\n element,\n context.shared,\n rightmost,\n );\n },\n Component::Combinator(_) => unsafe {\n debug_unreachable!(\"Shouldn't try to selector-match combinators\")\n },\n Component::RelativeSelectorAnchor => {\n let anchor = context.shared.relative_selector_anchor();\n // We may match inner relative selectors, in which case we want to always match.\n anchor.map_or(true, |a| a == element.opaque())\n },\n Component::Invalid(..) => false,\n })\n}\n\n#[inline(always)]\npub fn select_name<'a, E: Element, T: PartialEq>(\n element: &E,\n local_name: &'a T,\n local_name_lower: &'a T,\n) -> &'a T {\n if local_name == local_name_lower || element.is_html_element_in_html_document() {\n local_name_lower\n } else {\n local_name\n }\n}\n\n#[inline(always)]\npub fn to_unconditional_case_sensitivity<'a, E: Element>(\n parsed: ParsedCaseSensitivity,\n element: &E,\n) -> CaseSensitivity {\n match parsed {\n ParsedCaseSensitivity::CaseSensitive | ParsedCaseSensitivity::ExplicitCaseSensitive => {\n CaseSensitivity::CaseSensitive\n },\n ParsedCaseSensitivity::AsciiCaseInsensitive => CaseSensitivity::AsciiCaseInsensitive,\n ParsedCaseSensitivity::AsciiCaseInsensitiveIfInHtmlElementInHtmlDocument => {\n if element.is_html_element_in_html_document() {\n CaseSensitivity::AsciiCaseInsensitive\n } else {\n CaseSensitivity::CaseSensitive\n }\n },\n }\n}\n\nfn matches_generic_nth_child(\n element: &E,\n context: &mut MatchingContext,\n nth_data: &NthSelectorData,\n selectors: &[Selector],\n rightmost: SubjectOrPseudoElement,\n) -> KleeneValue\nwhere\n E: Element,\n{\n if element.ignores_nth_child_selectors() {\n return KleeneValue::False;\n }\n let has_selectors = !selectors.is_empty();\n let selectors_match = !has_selectors\n || matches_complex_selector_list(selectors, element, context, rightmost).to_bool(true);\n if let Some(may_return_unknown) = context.matching_for_invalidation_comparison() {\n // Skip expensive indexing math in invalidation.\n return if selectors_match && may_return_unknown {\n KleeneValue::Unknown\n } else {\n KleeneValue::from(selectors_match && !context.in_negation())\n };\n }\n\n let NthSelectorData { ty, an_plus_b, .. } = *nth_data;\n let is_of_type = ty.is_of_type();\n if ty.is_only() {\n debug_assert!(\n !has_selectors,\n \":only-child and :only-of-type cannot have a selector list!\"\n );\n return KleeneValue::from(\n matches_generic_nth_child(\n element,\n context,\n &NthSelectorData::first(is_of_type),\n selectors,\n rightmost,\n )\n .to_bool(true)\n && matches_generic_nth_child(\n element,\n context,\n &NthSelectorData::last(is_of_type),\n selectors,\n rightmost,\n )\n .to_bool(true),\n );\n }\n\n let is_from_end = ty.is_from_end();\n\n // It's useful to know whether this can only select the first/last element\n // child for optimization purposes, see the `HAS_EDGE_CHILD_SELECTOR` flag.\n let is_edge_child_selector = nth_data.is_simple_edge() && !has_selectors;\n\n if context.needs_selector_flags() {\n let mut flags = if is_edge_child_selector {\n ElementSelectorFlags::HAS_EDGE_CHILD_SELECTOR\n } else if is_from_end {\n ElementSelectorFlags::HAS_SLOW_SELECTOR\n } else {\n ElementSelectorFlags::HAS_SLOW_SELECTOR_LATER_SIBLINGS\n };\n flags |= if has_selectors {\n ElementSelectorFlags::HAS_SLOW_SELECTOR_NTH_OF\n } else {\n ElementSelectorFlags::HAS_SLOW_SELECTOR_NTH\n };\n element.apply_selector_flags(flags);\n }\n\n if !selectors_match {\n return KleeneValue::False;\n }\n\n // :first/last-child are rather trivial to match, don't bother with the\n // cache.\n if is_edge_child_selector {\n return if is_from_end {\n element.next_sibling_element()\n } else {\n element.prev_sibling_element()\n }\n .is_none()\n .into();\n }\n\n // Lookup or compute the index.\n let index = if let Some(i) = context\n .nth_index_cache(is_of_type, is_from_end, selectors)\n .lookup(element.opaque())\n {\n i\n } else {\n let i = nth_child_index(\n element,\n context,\n selectors,\n is_of_type,\n is_from_end,\n /* check_cache = */ true,\n rightmost,\n );\n context\n .nth_index_cache(is_of_type, is_from_end, selectors)\n .insert(element.opaque(), i);\n i\n };\n debug_assert_eq!(\n index,\n nth_child_index(\n element,\n context,\n selectors,\n is_of_type,\n is_from_end,\n /* check_cache = */ false,\n rightmost,\n ),\n \"invalid cache\"\n );\n\n an_plus_b.matches_index(index).into()\n}\n\n#[inline]\nfn nth_child_index(\n element: &E,\n context: &mut MatchingContext,\n selectors: &[Selector],\n is_of_type: bool,\n is_from_end: bool,\n check_cache: bool,\n rightmost: SubjectOrPseudoElement,\n) -> i32\nwhere\n E: Element,\n{\n // The traversal mostly processes siblings left to right. So when we walk\n // siblings to the right when computing NthLast/NthLastOfType we're unlikely\n // to get cache hits along the way. As such, we take the hit of walking the\n // siblings to the left checking the cache in the is_from_end case (this\n // matches what Gecko does). The indices-from-the-left is handled during the\n // regular look further below.\n if check_cache\n && is_from_end\n && !context\n .nth_index_cache(is_of_type, is_from_end, selectors)\n .is_empty()\n {\n let mut index: i32 = 1;\n let mut curr = element.clone();\n while let Some(e) = curr.prev_sibling_element() {\n curr = e;\n let matches = if is_of_type {\n element.is_same_type(&curr)\n } else if !selectors.is_empty() {\n matches_complex_selector_list(selectors, &curr, context, rightmost).to_bool(true)\n } else {\n true\n };\n if !matches {\n continue;\n }\n if let Some(i) = context\n .nth_index_cache(is_of_type, is_from_end, selectors)\n .lookup(curr.opaque())\n {\n return i - index;\n }\n index += 1;\n }\n }\n\n let mut index: i32 = 1;\n let mut curr = element.clone();\n let next = |e: E| {\n if is_from_end {\n e.next_sibling_element()\n } else {\n e.prev_sibling_element()\n }\n };\n while let Some(e) = next(curr) {\n curr = e;\n let matches = if is_of_type {\n element.is_same_type(&curr)\n } else if !selectors.is_empty() {\n matches_complex_selector_list(selectors, &curr, context, rightmost).to_bool(true)\n } else {\n true\n };\n if !matches {\n continue;\n }\n // If we're computing indices from the left, check each element in the\n // cache. We handle the indices-from-the-right case at the top of this\n // function.\n if !is_from_end && check_cache {\n if let Some(i) = context\n .nth_index_cache(is_of_type, is_from_end, selectors)\n .lookup(curr.opaque())\n {\n return i + index;\n }\n }\n index += 1;\n }\n\n index\n}\n" }, { "path": "selectors/nth_index_cache.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\nuse std::hash::Hash;\n\nuse crate::{parser::Selector, tree::OpaqueElement, SelectorImpl};\nuse rustc_hash::FxHashMap;\n\n/// A cache to speed up matching of nth-index-like selectors.\n///\n/// See [1] for some discussion around the design tradeoffs.\n///\n/// [1] https://bugzilla.mozilla.org/show_bug.cgi?id=1401855#c3\n#[derive(Default)]\npub struct NthIndexCache {\n nth: NthIndexCacheInner,\n nth_of_selectors: NthIndexOfSelectorsCaches,\n nth_last: NthIndexCacheInner,\n nth_last_of_selectors: NthIndexOfSelectorsCaches,\n nth_of_type: NthIndexCacheInner,\n nth_last_of_type: NthIndexCacheInner,\n}\n\nimpl NthIndexCache {\n /// Gets the appropriate cache for the given parameters.\n pub fn get(\n &mut self,\n is_of_type: bool,\n is_from_end: bool,\n selectors: &[Selector],\n ) -> &mut NthIndexCacheInner {\n if is_of_type {\n return if is_from_end {\n &mut self.nth_last_of_type\n } else {\n &mut self.nth_of_type\n };\n }\n if !selectors.is_empty() {\n return if is_from_end {\n self.nth_last_of_selectors.lookup(selectors)\n } else {\n self.nth_of_selectors.lookup(selectors)\n };\n }\n if is_from_end {\n &mut self.nth_last\n } else {\n &mut self.nth\n }\n }\n}\n\n#[derive(Hash, Eq, PartialEq)]\nstruct SelectorListCacheKey(usize);\n\n/// Use the selector list's pointer as the cache key\nimpl SelectorListCacheKey {\n // :nth-child of selectors are reference-counted with `ThinArc`, so we know their pointers are stable.\n fn new(selectors: &[Selector]) -> Self {\n Self(selectors.as_ptr() as usize)\n }\n}\n\n/// Use a different map of cached indices per :nth-child's or :nth-last-child's selector list\n#[derive(Default)]\npub struct NthIndexOfSelectorsCaches(FxHashMap);\n\n/// Get or insert a map of cached incides for the selector list of this\n/// particular :nth-child or :nth-last-child pseudoclass\nimpl NthIndexOfSelectorsCaches {\n pub fn lookup(\n &mut self,\n selectors: &[Selector],\n ) -> &mut NthIndexCacheInner {\n self.0\n .entry(SelectorListCacheKey::new(selectors))\n .or_default()\n }\n}\n\n/// The concrete per-pseudo-class cache.\n#[derive(Default)]\npub struct NthIndexCacheInner(FxHashMap);\n\nimpl NthIndexCacheInner {\n /// Does a lookup for a given element in the cache.\n pub fn lookup(&mut self, el: OpaqueElement) -> Option {\n self.0.get(&el).copied()\n }\n\n /// Inserts an entry into the cache.\n pub fn insert(&mut self, element: OpaqueElement, index: i32) {\n self.0.insert(element, index);\n }\n\n /// Returns whether the cache is empty.\n pub fn is_empty(&self) -> bool {\n self.0.is_empty()\n }\n}\n" }, { "path": "selectors/parser.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\nuse crate::attr::{AttrSelectorOperator, AttrSelectorWithOptionalNamespace};\nuse crate::attr::{NamespaceConstraint, ParsedAttrSelectorOperation, ParsedCaseSensitivity};\nuse crate::bloom::BLOOM_HASH_MASK;\nuse crate::builder::{\n relative_selector_list_specificity_and_flags, selector_list_specificity_and_flags,\n SelectorBuilder, SelectorFlags, Specificity, SpecificityAndFlags,\n};\nuse crate::context::QuirksMode;\nuse crate::sink::Push;\nuse crate::visitor::SelectorListKind;\npub use crate::visitor::SelectorVisitor;\nuse bitflags::bitflags;\nuse cssparser::match_ignore_ascii_case;\nuse cssparser::parse_nth;\nuse cssparser::{BasicParseError, BasicParseErrorKind, ParseError, ParseErrorKind};\nuse cssparser::{CowRcStr, Delimiter, SourceLocation};\nuse cssparser::{Parser as CssParser, ToCss, Token};\nuse debug_unreachable::debug_unreachable;\nuse precomputed_hash::PrecomputedHash;\nuse servo_arc::{Arc, ArcUnionBorrow, ThinArc, ThinArcUnion, UniqueArc};\nuse smallvec::SmallVec;\nuse std::borrow::{Borrow, Cow};\nuse std::fmt::{self, Debug};\nuse std::iter::Rev;\nuse std::slice;\n\n#[cfg(feature = \"to_shmem\")]\nuse to_shmem_derive::ToShmem;\n\n/// A trait that represents a pseudo-element.\npub trait PseudoElement: Sized + ToCss {\n /// The `SelectorImpl` this pseudo-element is used for.\n type Impl: SelectorImpl;\n\n /// Whether the pseudo-element supports a given state selector to the right\n /// of it.\n fn accepts_state_pseudo_classes(&self) -> bool {\n false\n }\n\n /// Whether this pseudo-element is valid after a ::slotted(..) pseudo.\n fn valid_after_slotted(&self) -> bool {\n false\n }\n\n /// Whether this pseudo-element is valid when directly after a ::before/::after pseudo.\n fn valid_after_before_or_after(&self) -> bool {\n false\n }\n\n /// Whether this pseudo-element is element-backed.\n /// https://drafts.csswg.org/css-pseudo-4/#element-like\n fn parses_as_element_backed(&self) -> bool {\n false\n }\n\n /// Whether this pseudo-element is ::before or ::after pseudo element,\n /// which are treated specially when deciding what can come after them.\n /// https://drafts.csswg.org/css-pseudo-4/#generated-content\n fn is_before_or_after(&self) -> bool {\n false\n }\n\n /// The count we contribute to the specificity from this pseudo-element.\n fn specificity_count(&self) -> u32 {\n 1\n }\n\n /// Whether this pseudo-element is in a pseudo-element tree (excluding the pseudo-element\n /// root).\n /// https://drafts.csswg.org/css-view-transitions-1/#pseudo-root\n fn is_in_pseudo_element_tree(&self) -> bool {\n false\n }\n}\n\n/// A trait that represents a pseudo-class.\npub trait NonTSPseudoClass: Sized + ToCss {\n /// The `SelectorImpl` this pseudo-element is used for.\n type Impl: SelectorImpl;\n\n /// Whether this pseudo-class is :active or :hover.\n fn is_active_or_hover(&self) -> bool;\n\n /// Whether this pseudo-class belongs to:\n ///\n /// https://drafts.csswg.org/selectors-4/#useraction-pseudos\n fn is_user_action_state(&self) -> bool;\n\n fn visit(&self, _visitor: &mut V) -> bool\n where\n V: SelectorVisitor,\n {\n true\n }\n}\n\n/// Returns a Cow::Borrowed if `s` is already ASCII lowercase, and a\n/// Cow::Owned if `s` had to be converted into ASCII lowercase.\nfn to_ascii_lowercase(s: &str) -> Cow<'_, str> {\n if let Some(first_uppercase) = s.bytes().position(|byte| byte >= b'A' && byte <= b'Z') {\n let mut string = s.to_owned();\n string[first_uppercase..].make_ascii_lowercase();\n string.into()\n } else {\n s.into()\n }\n}\n\nbitflags! {\n /// Flags that indicate at which point of parsing a selector are we.\n #[derive(Copy, Clone)]\n struct SelectorParsingState: u16 {\n /// Whether we should avoid adding default namespaces to selectors that\n /// aren't type or universal selectors.\n const SKIP_DEFAULT_NAMESPACE = 1 << 0;\n\n /// Whether we've parsed a ::slotted() pseudo-element already.\n ///\n /// If so, then we can only parse a subset of pseudo-elements, and\n /// whatever comes after them if so.\n const AFTER_SLOTTED = 1 << 1;\n /// Whether we've parsed a ::part() or element-backed pseudo-element already.\n ///\n /// If so, then we can only parse a subset of pseudo-elements, and\n /// whatever comes after them if so.\n const AFTER_PART_LIKE = 1 << 2;\n /// Whether we've parsed a non-element-backed pseudo-element (as in, an\n /// `Impl::PseudoElement` thus not accounting for `::slotted` or\n /// `::part`) already.\n ///\n /// If so, then other pseudo-elements and most other selectors are\n /// disallowed.\n const AFTER_NON_ELEMENT_BACKED_PSEUDO = 1 << 3;\n /// Whether we've parsed a non-stateful pseudo-element (again, as-in\n /// `Impl::PseudoElement`) already. If so, then other pseudo-classes are\n /// disallowed. If this flag is set, `AFTER_NON_ELEMENT_BACKED_PSEUDO` must be set\n /// as well.\n const AFTER_NON_STATEFUL_PSEUDO_ELEMENT = 1 << 4;\n // Whether we've parsed a generated pseudo-element (as in ::before, ::after).\n // If so then some other pseudo elements are disallowed (e.g. another generated pseudo)\n // while others allowed (e.g. ::marker).\n const AFTER_BEFORE_OR_AFTER_PSEUDO = 1 << 5;\n\n /// Whether we are after any of the pseudo-like things.\n const AFTER_PSEUDO = Self::AFTER_PART_LIKE.bits() | Self::AFTER_SLOTTED.bits() | Self::AFTER_NON_ELEMENT_BACKED_PSEUDO.bits() | Self::AFTER_BEFORE_OR_AFTER_PSEUDO.bits();\n\n /// Whether we explicitly disallow combinators.\n const DISALLOW_COMBINATORS = 1 << 6;\n\n /// Whether we explicitly disallow pseudo-element-like things.\n const DISALLOW_PSEUDOS = 1 << 7;\n\n /// Whether we explicitly disallow relative selectors (i.e. `:has()`).\n const DISALLOW_RELATIVE_SELECTOR = 1 << 8;\n\n /// Whether we've parsed a pseudo-element which is in a pseudo-element tree (i.e. it is a\n /// descendant pseudo of a pseudo-element root).\n const IN_PSEUDO_ELEMENT_TREE = 1 << 9;\n }\n}\n\nimpl SelectorParsingState {\n #[inline]\n fn allows_slotted(self) -> bool {\n !self.intersects(Self::AFTER_PSEUDO | Self::DISALLOW_PSEUDOS)\n }\n\n #[inline]\n fn allows_part(self) -> bool {\n !self.intersects(Self::AFTER_PSEUDO | Self::DISALLOW_PSEUDOS)\n }\n\n #[inline]\n fn allows_non_functional_pseudo_classes(self) -> bool {\n !self.intersects(Self::AFTER_SLOTTED | Self::AFTER_NON_STATEFUL_PSEUDO_ELEMENT)\n }\n\n #[inline]\n fn allows_tree_structural_pseudo_classes(self) -> bool {\n !self.intersects(Self::AFTER_PSEUDO) || self.intersects(Self::IN_PSEUDO_ELEMENT_TREE)\n }\n\n #[inline]\n fn allows_combinators(self) -> bool {\n !self.intersects(Self::DISALLOW_COMBINATORS)\n }\n\n #[inline]\n fn allows_only_child_pseudo_class_only(self) -> bool {\n self.intersects(Self::IN_PSEUDO_ELEMENT_TREE)\n }\n}\n\npub type SelectorParseError<'i> = ParseError<'i, SelectorParseErrorKind<'i>>;\n\n#[derive(Clone, Debug, PartialEq)]\npub enum SelectorParseErrorKind<'i> {\n NoQualifiedNameInAttributeSelector(Token<'i>),\n EmptySelector,\n DanglingCombinator,\n NonCompoundSelector,\n NonPseudoElementAfterSlotted,\n InvalidPseudoElementAfterSlotted,\n InvalidPseudoElementInsideWhere,\n InvalidState,\n UnexpectedTokenInAttributeSelector(Token<'i>),\n PseudoElementExpectedColon(Token<'i>),\n PseudoElementExpectedIdent(Token<'i>),\n NoIdentForPseudo(Token<'i>),\n UnsupportedPseudoClassOrElement(CowRcStr<'i>),\n UnexpectedIdent(CowRcStr<'i>),\n ExpectedNamespace(CowRcStr<'i>),\n ExpectedBarInAttr(Token<'i>),\n BadValueInAttr(Token<'i>),\n InvalidQualNameInAttr(Token<'i>),\n ExplicitNamespaceUnexpectedToken(Token<'i>),\n ClassNeedsIdent(Token<'i>),\n}\n\nmacro_rules! with_all_bounds {\n (\n [ $( $InSelector: tt )* ]\n [ $( $CommonBounds: tt )* ]\n [ $( $FromStr: tt )* ]\n ) => {\n /// This trait allows to define the parser implementation in regards\n /// of pseudo-classes/elements\n ///\n /// NB: We need Clone so that we can derive(Clone) on struct with that\n /// are parameterized on SelectorImpl. See\n /// \n pub trait SelectorImpl: Clone + Debug + Sized + 'static {\n type ExtraMatchingData<'a>: Sized + Default;\n type AttrValue: $($InSelector)*;\n type Identifier: $($InSelector)* + PrecomputedHash;\n type LocalName: $($InSelector)* + Borrow + PrecomputedHash;\n type NamespaceUrl: $($CommonBounds)* + Default + Borrow + PrecomputedHash;\n type NamespacePrefix: $($InSelector)* + Default;\n type BorrowedNamespaceUrl: ?Sized + Eq;\n type BorrowedLocalName: ?Sized + Eq;\n\n /// non tree-structural pseudo-classes\n /// (see: https://drafts.csswg.org/selectors/#structural-pseudos)\n type NonTSPseudoClass: $($CommonBounds)* + NonTSPseudoClass;\n\n /// pseudo-elements\n type PseudoElement: $($CommonBounds)* + PseudoElement;\n\n /// Whether attribute hashes should be collected for filtering\n /// purposes.\n fn should_collect_attr_hash(_name: &Self::LocalName) -> bool {\n false\n }\n }\n }\n}\n\nmacro_rules! with_bounds {\n ( [ $( $CommonBounds: tt )* ] [ $( $FromStr: tt )* ]) => {\n with_all_bounds! {\n [$($CommonBounds)* + $($FromStr)* + ToCss]\n [$($CommonBounds)*]\n [$($FromStr)*]\n }\n }\n}\n\nwith_bounds! {\n [Clone + Eq]\n [for<'a> From<&'a str>]\n}\n\npub trait Parser<'i> {\n type Impl: SelectorImpl;\n type Error: 'i + From>;\n\n /// Whether to parse the `::slotted()` pseudo-element.\n fn parse_slotted(&self) -> bool {\n false\n }\n\n /// Whether to parse the `::part()` pseudo-element.\n fn parse_part(&self) -> bool {\n false\n }\n\n /// Whether to parse the selector list of nth-child() or nth-last-child().\n fn parse_nth_child_of(&self) -> bool {\n false\n }\n\n /// Whether to parse `:is` and `:where` pseudo-classes.\n fn parse_is_and_where(&self) -> bool {\n false\n }\n\n /// Whether to parse the :has pseudo-class.\n fn parse_has(&self) -> bool {\n false\n }\n\n /// Whether to parse the '&' delimiter as a parent selector.\n fn parse_parent_selector(&self) -> bool {\n false\n }\n\n /// Whether the given function name is an alias for the `:is()` function.\n fn is_is_alias(&self, _name: &str) -> bool {\n false\n }\n\n /// Whether to parse the `:host` pseudo-class.\n fn parse_host(&self) -> bool {\n false\n }\n\n /// Whether to allow forgiving selector-list parsing.\n fn allow_forgiving_selectors(&self) -> bool {\n true\n }\n\n /// This function can return an \"Err\" pseudo-element in order to support CSS2.1\n /// pseudo-elements.\n fn parse_non_ts_pseudo_class(\n &self,\n location: SourceLocation,\n name: CowRcStr<'i>,\n ) -> Result<::NonTSPseudoClass, ParseError<'i, Self::Error>> {\n Err(\n location.new_custom_error(SelectorParseErrorKind::UnsupportedPseudoClassOrElement(\n name,\n )),\n )\n }\n\n fn parse_non_ts_functional_pseudo_class<'t>(\n &self,\n name: CowRcStr<'i>,\n parser: &mut CssParser<'i, 't>,\n _after_part: bool,\n ) -> Result<::NonTSPseudoClass, ParseError<'i, Self::Error>> {\n Err(\n parser.new_custom_error(SelectorParseErrorKind::UnsupportedPseudoClassOrElement(\n name,\n )),\n )\n }\n\n fn parse_pseudo_element(\n &self,\n location: SourceLocation,\n name: CowRcStr<'i>,\n ) -> Result<::PseudoElement, ParseError<'i, Self::Error>> {\n Err(\n location.new_custom_error(SelectorParseErrorKind::UnsupportedPseudoClassOrElement(\n name,\n )),\n )\n }\n\n fn parse_functional_pseudo_element<'t>(\n &self,\n name: CowRcStr<'i>,\n arguments: &mut CssParser<'i, 't>,\n ) -> Result<::PseudoElement, ParseError<'i, Self::Error>> {\n Err(\n arguments.new_custom_error(SelectorParseErrorKind::UnsupportedPseudoClassOrElement(\n name,\n )),\n )\n }\n\n fn default_namespace(&self) -> Option<::NamespaceUrl> {\n None\n }\n\n fn namespace_for_prefix(\n &self,\n _prefix: &::NamespacePrefix,\n ) -> Option<::NamespaceUrl> {\n None\n }\n}\n\n/// A selector list is a tagged pointer with either a single selector, or a ThinArc<()> of multiple\n/// selectors.\n#[derive(Clone, Eq, Debug, PartialEq)]\n#[cfg_attr(feature = \"to_shmem\", derive(ToShmem))]\n#[cfg_attr(feature = \"to_shmem\", shmem(no_bounds))]\npub struct SelectorList(\n #[cfg_attr(feature = \"to_shmem\", shmem(field_bound))]\n ThinArcUnion, (), Selector>,\n);\n\nimpl SelectorList {\n /// See Arc::mark_as_intentionally_leaked\n pub fn mark_as_intentionally_leaked(&self) {\n if let ArcUnionBorrow::Second(ref list) = self.0.borrow() {\n list.with_arc(|list| list.mark_as_intentionally_leaked())\n }\n self.slice()\n .iter()\n .for_each(|s| s.mark_as_intentionally_leaked())\n }\n\n pub fn from_one(selector: Selector) -> Self {\n #[cfg(debug_assertions)]\n let selector_repr = unsafe { *(&selector as *const _ as *const usize) };\n let list = Self(ThinArcUnion::from_first(selector.into_data()));\n #[cfg(debug_assertions)]\n debug_assert_eq!(\n selector_repr,\n unsafe { *(&list as *const _ as *const usize) },\n \"We rely on the same bit representation for the single selector variant\"\n );\n list\n }\n\n pub fn from_iter(mut iter: impl ExactSizeIterator>) -> Self {\n if iter.len() == 1 {\n Self::from_one(iter.next().unwrap())\n } else {\n Self(ThinArcUnion::from_second(ThinArc::from_header_and_iter(\n (),\n iter,\n )))\n }\n }\n\n #[inline]\n pub fn slice(&self) -> &[Selector] {\n match self.0.borrow() {\n ArcUnionBorrow::First(..) => {\n // SAFETY: see from_one.\n let selector: &Selector = unsafe { std::mem::transmute(self) };\n std::slice::from_ref(selector)\n },\n ArcUnionBorrow::Second(list) => list.get().slice(),\n }\n }\n\n #[inline]\n pub fn len(&self) -> usize {\n match self.0.borrow() {\n ArcUnionBorrow::First(..) => 1,\n ArcUnionBorrow::Second(list) => list.len(),\n }\n }\n\n /// Returns the address on the heap of the ThinArc for memory reporting.\n pub fn thin_arc_heap_ptr(&self) -> *const ::std::os::raw::c_void {\n match self.0.borrow() {\n ArcUnionBorrow::First(s) => s.with_arc(|a| a.heap_ptr()),\n ArcUnionBorrow::Second(s) => s.with_arc(|a| a.heap_ptr()),\n }\n }\n}\n\n/// Uniquely identify a selector based on its components, which is behind ThinArc and\n/// is therefore stable.\n#[derive(Clone, Copy, Hash, Eq, PartialEq)]\npub struct SelectorKey(usize);\n\nimpl SelectorKey {\n /// Create a new key based on the given selector.\n pub fn new(selector: &Selector) -> Self {\n Self(selector.0.slice().as_ptr() as usize)\n }\n}\n\n/// Whether or not we're using forgiving parsing mode\n#[derive(PartialEq)]\nenum ForgivingParsing {\n /// Discard the entire selector list upon encountering any invalid selector.\n /// This is the default behavior for almost all of CSS.\n No,\n /// Ignore invalid selectors, potentially creating an empty selector list.\n ///\n /// This is the error recovery mode of :is() and :where()\n Yes,\n}\n\n/// Flag indicating if we're parsing relative selectors.\n#[derive(Copy, Clone, PartialEq)]\npub enum ParseRelative {\n /// Expect selectors to start with a combinator, assuming descendant combinator if not present.\n ForHas,\n /// Allow selectors to start with a combinator, prepending a parent selector if so. Do nothing\n /// otherwise\n ForNesting,\n /// Allow selectors to start with a combinator, prepending a scope selector if so. Do nothing\n /// otherwise\n ForScope,\n /// Treat as parse error if any selector begins with a combinator.\n No,\n}\n\nimpl SelectorList {\n /// Returns a selector list with a single `:scope` selector (with specificity)\n pub fn scope() -> Self {\n Self::from_one(Selector::scope())\n }\n /// Returns a selector list with a single implicit `:scope` selector (no specificity)\n pub fn implicit_scope() -> Self {\n Self::from_one(Selector::implicit_scope())\n }\n\n /// Parse a comma-separated list of Selectors.\n /// \n ///\n /// Return the Selectors or Err if there is an invalid selector.\n pub fn parse<'i, 't, P>(\n parser: &P,\n input: &mut CssParser<'i, 't>,\n parse_relative: ParseRelative,\n ) -> Result>\n where\n P: Parser<'i, Impl = Impl>,\n {\n Self::parse_with_state(\n parser,\n input,\n SelectorParsingState::empty(),\n ForgivingParsing::No,\n parse_relative,\n )\n }\n\n /// Same as `parse`, but disallow parsing of pseudo-elements.\n pub fn parse_disallow_pseudo<'i, 't, P>(\n parser: &P,\n input: &mut CssParser<'i, 't>,\n parse_relative: ParseRelative,\n ) -> Result>\n where\n P: Parser<'i, Impl = Impl>,\n {\n Self::parse_with_state(\n parser,\n input,\n SelectorParsingState::DISALLOW_PSEUDOS,\n ForgivingParsing::No,\n parse_relative,\n )\n }\n\n pub fn parse_forgiving<'i, 't, P>(\n parser: &P,\n input: &mut CssParser<'i, 't>,\n parse_relative: ParseRelative,\n ) -> Result>\n where\n P: Parser<'i, Impl = Impl>,\n {\n Self::parse_with_state(\n parser,\n input,\n SelectorParsingState::empty(),\n ForgivingParsing::Yes,\n parse_relative,\n )\n }\n\n #[inline]\n fn parse_with_state<'i, 't, P>(\n parser: &P,\n input: &mut CssParser<'i, 't>,\n state: SelectorParsingState,\n recovery: ForgivingParsing,\n parse_relative: ParseRelative,\n ) -> Result>\n where\n P: Parser<'i, Impl = Impl>,\n {\n let mut values = SmallVec::<[_; 4]>::new();\n let forgiving = recovery == ForgivingParsing::Yes && parser.allow_forgiving_selectors();\n loop {\n let selector = input.parse_until_before(Delimiter::Comma, |input| {\n let start = input.position();\n let mut selector = parse_selector(parser, input, state, parse_relative);\n if forgiving && (selector.is_err() || input.expect_exhausted().is_err()) {\n input.expect_no_error_token()?;\n selector = Ok(Selector::new_invalid(input.slice_from(start)));\n }\n selector\n })?;\n\n values.push(selector);\n\n match input.next() {\n Ok(&Token::Comma) => {},\n Ok(_) => unreachable!(),\n Err(_) => break,\n }\n }\n Ok(Self::from_iter(values.into_iter()))\n }\n\n /// Replaces the parent selector in all the items of the selector list.\n pub fn replace_parent_selector(&self, parent: &SelectorList) -> Self {\n Self::from_iter(\n self.slice()\n .iter()\n .map(|selector| selector.replace_parent_selector(parent)),\n )\n }\n\n /// Creates a SelectorList from a Vec of selectors. Used in tests.\n #[allow(dead_code)]\n pub(crate) fn from_vec(v: Vec>) -> Self {\n SelectorList::from_iter(v.into_iter())\n }\n}\n\n/// Parses one compound selector suitable for nested stuff like :-moz-any, etc.\nfn parse_inner_compound_selector<'i, 't, P, Impl>(\n parser: &P,\n input: &mut CssParser<'i, 't>,\n state: SelectorParsingState,\n) -> Result, ParseError<'i, P::Error>>\nwhere\n P: Parser<'i, Impl = Impl>,\n Impl: SelectorImpl,\n{\n parse_selector(\n parser,\n input,\n state | SelectorParsingState::DISALLOW_PSEUDOS | SelectorParsingState::DISALLOW_COMBINATORS,\n ParseRelative::No,\n )\n}\n\n/// Ancestor hashes for the bloom filter. We precompute these and store them\n/// inline with selectors to optimize cache performance during matching.\n/// This matters a lot.\n///\n/// We use 4 hashes, which is copied from Gecko, who copied it from WebKit.\n/// Note that increasing the number of hashes here will adversely affect the\n/// cache hit when fast-rejecting long lists of Rules with inline hashes.\n///\n/// Because the bloom filter only uses the bottom 24 bits of the hash, we pack\n/// the fourth hash into the upper bits of the first three hashes in order to\n/// shrink Rule (whose size matters a lot). This scheme minimizes the runtime\n/// overhead of the packing for the first three hashes (we just need to mask\n/// off the upper bits) at the expense of making the fourth somewhat more\n/// complicated to assemble, because we often bail out before checking all the\n/// hashes.\n#[derive(Clone, Debug, Eq, PartialEq)]\npub struct AncestorHashes {\n pub packed_hashes: [u32; 3],\n}\n\npub(crate) fn collect_selector_hashes<'a, Impl: SelectorImpl, Iter>(\n iter: Iter,\n quirks_mode: QuirksMode,\n hashes: &mut [u32; 4],\n len: &mut usize,\n create_inner_iterator: fn(&'a Selector) -> Iter,\n) -> bool\nwhere\n Iter: Iterator>,\n{\n for component in iter {\n let hash = match *component {\n Component::LocalName(LocalName {\n ref name,\n ref lower_name,\n }) => {\n // Only insert the local-name into the filter if it's all\n // lowercase. Otherwise we would need to test both hashes, and\n // our data structures aren't really set up for that.\n if name != lower_name {\n continue;\n }\n name.precomputed_hash()\n },\n Component::DefaultNamespace(ref url) | Component::Namespace(_, ref url) => {\n url.precomputed_hash()\n },\n // In quirks mode, class and id selectors should match\n // case-insensitively, so just avoid inserting them into the filter.\n Component::ID(ref id) if quirks_mode != QuirksMode::Quirks => id.precomputed_hash(),\n Component::Class(ref class) if quirks_mode != QuirksMode::Quirks => {\n class.precomputed_hash()\n },\n Component::AttributeInNoNamespace { ref local_name, .. }\n if Impl::should_collect_attr_hash(local_name) =>\n {\n // AttributeInNoNamespace is only used when local_name ==\n // local_name_lower.\n local_name.precomputed_hash()\n },\n Component::AttributeInNoNamespaceExists {\n ref local_name,\n ref local_name_lower,\n ..\n } => {\n // Only insert the local-name into the filter if it's all\n // lowercase. Otherwise we would need to test both hashes, and\n // our data structures aren't really set up for that.\n if local_name != local_name_lower || !Impl::should_collect_attr_hash(local_name) {\n continue;\n }\n local_name.precomputed_hash()\n },\n Component::AttributeOther(ref selector) => {\n if selector.local_name != selector.local_name_lower\n || !Impl::should_collect_attr_hash(&selector.local_name)\n {\n continue;\n }\n selector.local_name.precomputed_hash()\n },\n Component::Is(ref list) | Component::Where(ref list) => {\n // :where and :is OR their selectors, so we can't put any hash\n // in the filter if there's more than one selector, as that'd\n // exclude elements that may match one of the other selectors.\n let slice = list.slice();\n if slice.len() == 1\n && !collect_selector_hashes(\n create_inner_iterator(&slice[0]),\n quirks_mode,\n hashes,\n len,\n create_inner_iterator,\n )\n {\n return false;\n }\n continue;\n },\n _ => continue,\n };\n\n hashes[*len] = hash & BLOOM_HASH_MASK;\n *len += 1;\n if *len == hashes.len() {\n return false;\n }\n }\n true\n}\n\nfn collect_ancestor_hashes(\n iter: SelectorIter,\n quirks_mode: QuirksMode,\n hashes: &mut [u32; 4],\n len: &mut usize,\n) {\n collect_selector_hashes(AncestorIter::new(iter), quirks_mode, hashes, len, |s| {\n AncestorIter(s.iter())\n });\n}\n\nimpl AncestorHashes {\n pub fn new(selector: &Selector, quirks_mode: QuirksMode) -> Self {\n // Compute ancestor hashes for the bloom filter.\n let mut hashes = [0u32; 4];\n let mut len = 0;\n collect_ancestor_hashes(selector.iter(), quirks_mode, &mut hashes, &mut len);\n debug_assert!(len <= 4);\n\n // Now, pack the fourth hash (if it exists) into the upper byte of each of\n // the other three hashes.\n if len == 4 {\n let fourth = hashes[3];\n hashes[0] |= (fourth & 0x000000ff) << 24;\n hashes[1] |= (fourth & 0x0000ff00) << 16;\n hashes[2] |= (fourth & 0x00ff0000) << 8;\n }\n\n AncestorHashes {\n packed_hashes: [hashes[0], hashes[1], hashes[2]],\n }\n }\n\n /// Returns the fourth hash, reassembled from parts.\n pub fn fourth_hash(&self) -> u32 {\n ((self.packed_hashes[0] & 0xff000000) >> 24)\n | ((self.packed_hashes[1] & 0xff000000) >> 16)\n | ((self.packed_hashes[2] & 0xff000000) >> 8)\n }\n}\n\n#[inline]\npub fn namespace_empty_string() -> Impl::NamespaceUrl {\n // Rust type’s default, not default namespace\n Impl::NamespaceUrl::default()\n}\n\npub(super) type SelectorData = ThinArc>;\n\n/// Whether a selector may match a featureless host element, and whether it may match other\n/// elements.\n#[derive(Clone, Copy, Debug, Eq, PartialEq)]\npub enum MatchesFeaturelessHost {\n /// The selector may match a featureless host, but also a non-featureless element.\n Yes,\n /// The selector is guaranteed to never match a non-featureless host element.\n Only,\n /// The selector never matches a featureless host.\n Never,\n}\n\nimpl MatchesFeaturelessHost {\n /// Whether we may match.\n #[inline]\n pub fn may_match(self) -> bool {\n return !matches!(self, Self::Never);\n }\n}\n\n/// A Selector stores a sequence of simple selectors and combinators. The\n/// iterator classes allow callers to iterate at either the raw sequence level or\n/// at the level of sequences of simple selectors separated by combinators. Most\n/// callers want the higher-level iterator.\n///\n/// We store compound selectors internally right-to-left (in matching order).\n/// Additionally, we invert the order of top-level compound selectors so that\n/// each one matches left-to-right. This is because matching namespace, local name,\n/// id, and class are all relatively cheap, whereas matching pseudo-classes might\n/// be expensive (depending on the pseudo-class). Since authors tend to put the\n/// pseudo-classes on the right, it's faster to start matching on the left.\n///\n/// This reordering doesn't change the semantics of selector matching, and we\n/// handle it in to_css to make it invisible to serialization.\n#[derive(Clone, Eq, PartialEq)]\n#[cfg_attr(feature = \"to_shmem\", derive(ToShmem))]\n#[cfg_attr(feature = \"to_shmem\", shmem(no_bounds))]\n#[repr(transparent)]\npub struct Selector(\n #[cfg_attr(feature = \"to_shmem\", shmem(field_bound))] SelectorData,\n);\n\nimpl Selector {\n /// See Arc::mark_as_intentionally_leaked\n pub fn mark_as_intentionally_leaked(&self) {\n self.0.mark_as_intentionally_leaked()\n }\n\n fn scope() -> Self {\n Self(ThinArc::from_header_and_iter(\n SpecificityAndFlags {\n specificity: Specificity::single_class_like().into(),\n flags: SelectorFlags::HAS_SCOPE,\n },\n std::iter::once(Component::Scope),\n ))\n }\n\n /// An implicit scope selector, much like :where(:scope).\n fn implicit_scope() -> Self {\n Self(ThinArc::from_header_and_iter(\n SpecificityAndFlags {\n specificity: 0,\n flags: SelectorFlags::HAS_SCOPE,\n },\n std::iter::once(Component::ImplicitScope),\n ))\n }\n\n #[inline]\n pub fn specificity(&self) -> u32 {\n self.0.header.specificity\n }\n\n #[inline]\n pub(crate) fn flags(&self) -> SelectorFlags {\n self.0.header.flags\n }\n\n #[inline]\n pub fn has_pseudo_element(&self) -> bool {\n self.flags().intersects(SelectorFlags::HAS_PSEUDO)\n }\n\n #[inline]\n pub fn has_parent_selector(&self) -> bool {\n self.flags().intersects(SelectorFlags::HAS_PARENT)\n }\n\n #[inline]\n pub fn has_scope_selector(&self) -> bool {\n self.flags().intersects(SelectorFlags::HAS_SCOPE)\n }\n\n #[inline]\n pub fn is_slotted(&self) -> bool {\n self.flags().intersects(SelectorFlags::HAS_SLOTTED)\n }\n\n #[inline]\n pub fn is_part(&self) -> bool {\n self.flags().intersects(SelectorFlags::HAS_PART)\n }\n\n #[inline]\n pub fn parts(&self) -> Option<&[Impl::Identifier]> {\n if !self.is_part() {\n return None;\n }\n\n let mut iter = self.iter();\n if self.has_pseudo_element() {\n // Skip the pseudo-element.\n for _ in &mut iter {}\n\n let combinator = iter.next_sequence()?;\n debug_assert_eq!(combinator, Combinator::PseudoElement);\n }\n\n for component in iter {\n if let Component::Part(ref part) = *component {\n return Some(part);\n }\n }\n\n debug_assert!(false, \"is_part() lied somehow?\");\n None\n }\n\n #[inline]\n pub fn pseudo_element(&self) -> Option<&Impl::PseudoElement> {\n if !self.has_pseudo_element() {\n return None;\n }\n\n for component in self.iter() {\n if let Component::PseudoElement(ref pseudo) = *component {\n return Some(pseudo);\n }\n }\n\n debug_assert!(false, \"has_pseudo_element lied!\");\n None\n }\n\n #[inline]\n pub fn pseudo_elements(&self) -> SmallVec<[&Impl::PseudoElement; 3]> {\n let mut pseudos = SmallVec::new();\n\n if !self.has_pseudo_element() {\n return pseudos;\n }\n\n let mut iter = self.iter();\n loop {\n for component in &mut iter {\n if let Component::PseudoElement(ref pseudo) = *component {\n pseudos.push(pseudo);\n }\n }\n match iter.next_sequence() {\n Some(Combinator::PseudoElement) => {},\n _ => break,\n }\n }\n\n debug_assert!(!pseudos.is_empty(), \"has_pseudo_element lied!\");\n\n pseudos\n }\n\n /// Whether this selector (pseudo-element part excluded) matches every element.\n ///\n /// Used for \"pre-computed\" pseudo-elements in components/style/stylist.rs\n #[inline]\n pub fn is_universal(&self) -> bool {\n self.iter_raw_match_order().all(|c| {\n matches!(\n *c,\n Component::ExplicitUniversalType\n | Component::ExplicitAnyNamespace\n | Component::Combinator(Combinator::PseudoElement)\n | Component::PseudoElement(..)\n )\n })\n }\n\n /// Whether this selector may match a featureless shadow host, with no combinators to the\n /// left, and optionally has a pseudo-element to the right.\n #[inline]\n pub fn matches_featureless_host(\n &self,\n scope_matches_featureless_host: bool,\n ) -> MatchesFeaturelessHost {\n let flags = self.flags();\n if !flags.intersects(SelectorFlags::HAS_HOST | SelectorFlags::HAS_SCOPE) {\n return MatchesFeaturelessHost::Never;\n }\n\n let mut iter = self.iter();\n if flags.intersects(SelectorFlags::HAS_PSEUDO) {\n for _ in &mut iter {\n // Skip over pseudo-elements\n }\n match iter.next_sequence() {\n Some(c) if c.is_pseudo_element() => {},\n _ => {\n debug_assert!(false, \"Pseudo selector without pseudo combinator?\");\n return MatchesFeaturelessHost::Never;\n },\n }\n }\n\n let compound_matches = crate::matching::compound_matches_featureless_host(\n &mut iter,\n scope_matches_featureless_host,\n );\n if iter.next_sequence().is_some() {\n return MatchesFeaturelessHost::Never;\n }\n return compound_matches;\n }\n\n /// Returns an iterator over this selector in matching order (right-to-left).\n /// When a combinator is reached, the iterator will return None, and\n /// next_sequence() may be called to continue to the next sequence.\n #[inline]\n pub fn iter(&self) -> SelectorIter<'_, Impl> {\n SelectorIter {\n iter: self.iter_raw_match_order(),\n next_combinator: None,\n }\n }\n\n /// Same as `iter()`, but skips `RelativeSelectorAnchor` and its associated combinator.\n #[inline]\n pub fn iter_skip_relative_selector_anchor(&self) -> SelectorIter<'_, Impl> {\n if cfg!(debug_assertions) {\n let mut selector_iter = self.iter_raw_parse_order_from(0);\n assert!(\n matches!(\n selector_iter.next().unwrap(),\n Component::RelativeSelectorAnchor\n ),\n \"Relative selector does not start with RelativeSelectorAnchor\"\n );\n assert!(\n selector_iter.next().unwrap().is_combinator(),\n \"Relative combinator does not exist\"\n );\n }\n\n SelectorIter {\n iter: self.0.slice()[..self.len() - 2].iter(),\n next_combinator: None,\n }\n }\n\n /// Returns an iterator over this selector in matching order (right-to-left),\n /// skipping the rightmost |offset| Components.\n #[inline]\n pub fn iter_from(&self, offset: usize) -> SelectorIter<'_, Impl> {\n let iter = self.0.slice()[offset..].iter();\n SelectorIter {\n iter,\n next_combinator: None,\n }\n }\n\n /// Returns the combinator at index `index` (zero-indexed from the right),\n /// or panics if the component is not a combinator.\n #[inline]\n pub fn combinator_at_match_order(&self, index: usize) -> Combinator {\n match self.0.slice()[index] {\n Component::Combinator(c) => c,\n ref other => panic!(\n \"Not a combinator: {:?}, {:?}, index: {}\",\n other, self, index\n ),\n }\n }\n\n /// Returns an iterator over the entire sequence of simple selectors and\n /// combinators, in matching order (from right to left).\n #[inline]\n pub fn iter_raw_match_order(&self) -> slice::Iter<'_, Component> {\n self.0.slice().iter()\n }\n\n /// Returns the combinator at index `index` (zero-indexed from the left),\n /// or panics if the component is not a combinator.\n #[inline]\n pub fn combinator_at_parse_order(&self, index: usize) -> Combinator {\n match self.0.slice()[self.len() - index - 1] {\n Component::Combinator(c) => c,\n ref other => panic!(\n \"Not a combinator: {:?}, {:?}, index: {}\",\n other, self, index\n ),\n }\n }\n\n /// Returns an iterator over the sequence of simple selectors and\n /// combinators, in parse order (from left to right), starting from\n /// `offset`.\n #[inline]\n pub fn iter_raw_parse_order_from(\n &self,\n offset: usize,\n ) -> Rev>> {\n self.0.slice()[..self.len() - offset].iter().rev()\n }\n\n /// Creates a Selector from a vec of Components, specified in parse order. Used in tests.\n #[allow(dead_code)]\n pub(crate) fn from_vec(\n vec: Vec>,\n specificity: u32,\n flags: SelectorFlags,\n ) -> Self {\n let mut builder = SelectorBuilder::default();\n for component in vec.into_iter() {\n if let Some(combinator) = component.as_combinator() {\n builder.push_combinator(combinator);\n } else {\n builder.push_simple_selector(component);\n }\n }\n let spec = SpecificityAndFlags { specificity, flags };\n Selector(builder.build_with_specificity_and_flags(spec, ParseRelative::No))\n }\n\n #[inline]\n fn into_data(self) -> SelectorData {\n self.0\n }\n\n pub fn replace_parent_selector(&self, parent: &SelectorList) -> Self {\n let parent_specificity_and_flags = selector_list_specificity_and_flags(\n parent.slice().iter(),\n /* for_nesting_parent = */ true,\n );\n\n let mut specificity = Specificity::from(self.specificity());\n let mut flags = self.flags() - SelectorFlags::HAS_PARENT;\n let forbidden_flags = SelectorFlags::forbidden_for_nesting();\n\n fn replace_parent_on_selector_list(\n orig: &[Selector],\n parent: &SelectorList,\n specificity: &mut Specificity,\n flags: &mut SelectorFlags,\n propagate_specificity: bool,\n forbidden_flags: SelectorFlags,\n ) -> Option> {\n if !orig.iter().any(|s| s.has_parent_selector()) {\n return None;\n }\n\n let result =\n SelectorList::from_iter(orig.iter().map(|s| s.replace_parent_selector(parent)));\n\n let result_specificity_and_flags = selector_list_specificity_and_flags(\n result.slice().iter(),\n /* for_nesting_parent = */ false,\n );\n if propagate_specificity {\n *specificity += Specificity::from(\n result_specificity_and_flags.specificity\n - selector_list_specificity_and_flags(\n orig.iter(),\n /* for_nesting_parent = */ false,\n )\n .specificity,\n );\n }\n flags.insert(result_specificity_and_flags.flags - forbidden_flags);\n Some(result)\n }\n\n fn replace_parent_on_relative_selector_list(\n orig: &[RelativeSelector],\n parent: &SelectorList,\n specificity: &mut Specificity,\n flags: &mut SelectorFlags,\n forbidden_flags: SelectorFlags,\n ) -> Vec> {\n let mut any = false;\n\n let result = orig\n .iter()\n .map(|s| {\n if !s.selector.has_parent_selector() {\n return s.clone();\n }\n any = true;\n RelativeSelector {\n match_hint: s.match_hint,\n selector: s.selector.replace_parent_selector(parent),\n }\n })\n .collect();\n\n if !any {\n return result;\n }\n\n let result_specificity_and_flags = relative_selector_list_specificity_and_flags(\n &result, /* for_nesting_parent = */ false,\n );\n flags.insert(result_specificity_and_flags.flags - forbidden_flags);\n *specificity += Specificity::from(\n result_specificity_and_flags.specificity\n - relative_selector_list_specificity_and_flags(\n orig, /* for_nesting_parent = */ false,\n )\n .specificity,\n );\n result\n }\n\n fn replace_parent_on_selector(\n orig: &Selector,\n parent: &SelectorList,\n specificity: &mut Specificity,\n flags: &mut SelectorFlags,\n forbidden_flags: SelectorFlags,\n ) -> Selector {\n let new_selector = orig.replace_parent_selector(parent);\n *specificity += Specificity::from(new_selector.specificity() - orig.specificity());\n flags.insert(new_selector.flags() - forbidden_flags);\n new_selector\n }\n\n if !self.has_parent_selector() {\n return self.clone();\n }\n\n let iter = self.iter_raw_match_order().map(|component| {\n use self::Component::*;\n match *component {\n LocalName(..)\n | ID(..)\n | Class(..)\n | AttributeInNoNamespaceExists { .. }\n | AttributeInNoNamespace { .. }\n | AttributeOther(..)\n | ExplicitUniversalType\n | ExplicitAnyNamespace\n | ExplicitNoNamespace\n | DefaultNamespace(..)\n | Namespace(..)\n | Root\n | Empty\n | Scope\n | ImplicitScope\n | Nth(..)\n | NonTSPseudoClass(..)\n | PseudoElement(..)\n | Combinator(..)\n | Host(None)\n | Part(..)\n | Invalid(..)\n | RelativeSelectorAnchor => component.clone(),\n ParentSelector => {\n specificity += Specificity::from(parent_specificity_and_flags.specificity);\n flags.insert(parent_specificity_and_flags.flags - forbidden_flags);\n Is(parent.clone())\n },\n Negation(ref selectors) => {\n Negation(\n replace_parent_on_selector_list(\n selectors.slice(),\n parent,\n &mut specificity,\n &mut flags,\n /* propagate_specificity = */ true,\n forbidden_flags,\n )\n .unwrap_or_else(|| selectors.clone()),\n )\n },\n Is(ref selectors) => {\n Is(replace_parent_on_selector_list(\n selectors.slice(),\n parent,\n &mut specificity,\n &mut flags,\n /* propagate_specificity = */ true,\n forbidden_flags,\n )\n .unwrap_or_else(|| selectors.clone()))\n },\n Where(ref selectors) => {\n Where(\n replace_parent_on_selector_list(\n selectors.slice(),\n parent,\n &mut specificity,\n &mut flags,\n /* propagate_specificity = */ false,\n forbidden_flags,\n )\n .unwrap_or_else(|| selectors.clone()),\n )\n },\n Has(ref selectors) => Has(replace_parent_on_relative_selector_list(\n selectors,\n parent,\n &mut specificity,\n &mut flags,\n forbidden_flags,\n )\n .into_boxed_slice()),\n\n Host(Some(ref selector)) => Host(Some(replace_parent_on_selector(\n selector,\n parent,\n &mut specificity,\n &mut flags,\n forbidden_flags,\n ))),\n NthOf(ref data) => {\n let selectors = replace_parent_on_selector_list(\n data.selectors(),\n parent,\n &mut specificity,\n &mut flags,\n /* propagate_specificity = */ true,\n forbidden_flags,\n );\n NthOf(match selectors {\n Some(s) => {\n NthOfSelectorData::new(data.nth_data(), s.slice().iter().cloned())\n },\n None => data.clone(),\n })\n },\n Slotted(ref selector) => Slotted(replace_parent_on_selector(\n selector,\n parent,\n &mut specificity,\n &mut flags,\n forbidden_flags,\n )),\n }\n });\n let mut items = UniqueArc::from_header_and_iter(Default::default(), iter);\n *items.header_mut() = SpecificityAndFlags {\n specificity: specificity.into(),\n flags,\n };\n Selector(items.shareable())\n }\n\n /// Returns count of simple selectors and combinators in the Selector.\n #[inline]\n pub fn len(&self) -> usize {\n self.0.len()\n }\n\n /// Returns the address on the heap of the ThinArc for memory reporting.\n pub fn thin_arc_heap_ptr(&self) -> *const ::std::os::raw::c_void {\n self.0.heap_ptr()\n }\n\n /// Traverse selector components inside `self`.\n ///\n /// Implementations of this method should call `SelectorVisitor` methods\n /// or other impls of `Visit` as appropriate based on the fields of `Self`.\n ///\n /// A return value of `false` indicates terminating the traversal.\n /// It should be propagated with an early return.\n /// On the contrary, `true` indicates that all fields of `self` have been traversed:\n ///\n /// ```rust,ignore\n /// if !visitor.visit_simple_selector(&self.some_simple_selector) {\n /// return false;\n /// }\n /// if !self.some_component.visit(visitor) {\n /// return false;\n /// }\n /// true\n /// ```\n pub fn visit(&self, visitor: &mut V) -> bool\n where\n V: SelectorVisitor,\n {\n let mut current = self.iter();\n let mut combinator = None;\n loop {\n if !visitor.visit_complex_selector(combinator) {\n return false;\n }\n\n for selector in &mut current {\n if !selector.visit(visitor) {\n return false;\n }\n }\n\n combinator = current.next_sequence();\n if combinator.is_none() {\n break;\n }\n }\n\n true\n }\n\n /// Parse a selector, without any pseudo-element.\n #[inline]\n pub fn parse<'i, 't, P>(\n parser: &P,\n input: &mut CssParser<'i, 't>,\n ) -> Result>\n where\n P: Parser<'i, Impl = Impl>,\n {\n parse_selector(\n parser,\n input,\n SelectorParsingState::empty(),\n ParseRelative::No,\n )\n }\n\n pub fn new_invalid(s: &str) -> Self {\n fn check_for_parent(input: &mut CssParser, has_parent: &mut bool) {\n while let Ok(t) = input.next() {\n match *t {\n Token::Function(_)\n | Token::ParenthesisBlock\n | Token::CurlyBracketBlock\n | Token::SquareBracketBlock => {\n let _ = input.parse_nested_block(\n |i| -> Result<(), ParseError<'_, BasicParseError>> {\n check_for_parent(i, has_parent);\n Ok(())\n },\n );\n },\n Token::Delim('&') => {\n *has_parent = true;\n },\n _ => {},\n }\n if *has_parent {\n break;\n }\n }\n }\n let mut has_parent = false;\n {\n let mut parser = cssparser::ParserInput::new(s);\n let mut parser = CssParser::new(&mut parser);\n check_for_parent(&mut parser, &mut has_parent);\n }\n Self(ThinArc::from_header_and_iter(\n SpecificityAndFlags {\n specificity: 0,\n flags: if has_parent {\n SelectorFlags::HAS_PARENT\n } else {\n SelectorFlags::empty()\n },\n },\n std::iter::once(Component::Invalid(Arc::new(String::from(s.trim())))),\n ))\n }\n\n /// Is the compound starting at the offset the subject compound, or referring to its pseudo-element?\n pub fn is_rightmost(&self, offset: usize) -> bool {\n // There can really be only one pseudo-element, and it's not really valid for anything else to\n // follow it.\n offset == 0\n || matches!(\n self.combinator_at_match_order(offset - 1),\n Combinator::PseudoElement\n )\n }\n}\n\n#[derive(Clone)]\npub struct SelectorIter<'a, Impl: 'a + SelectorImpl> {\n iter: slice::Iter<'a, Component>,\n next_combinator: Option,\n}\n\nimpl<'a, Impl: 'a + SelectorImpl> SelectorIter<'a, Impl> {\n /// Prepares this iterator to point to the next sequence to the left,\n /// returning the combinator if the sequence was found.\n #[inline]\n pub fn next_sequence(&mut self) -> Option {\n self.next_combinator.take()\n }\n\n #[inline]\n pub(crate) fn matches_for_stateless_pseudo_element(&mut self) -> bool {\n let first = match self.next() {\n Some(c) => c,\n // Note that this is the common path that we keep inline: the\n // pseudo-element not having anything to its right.\n None => return true,\n };\n self.matches_for_stateless_pseudo_element_internal(first)\n }\n\n #[inline(never)]\n fn matches_for_stateless_pseudo_element_internal(&mut self, first: &Component) -> bool {\n if !first.matches_for_stateless_pseudo_element() {\n return false;\n }\n for component in self {\n // The only other parser-allowed Components in this sequence are\n // state pseudo-classes, or one of the other things that can contain\n // them.\n if !component.matches_for_stateless_pseudo_element() {\n return false;\n }\n }\n true\n }\n\n /// Returns remaining count of the simple selectors and combinators in the Selector.\n #[inline]\n pub fn selector_length(&self) -> usize {\n self.iter.len()\n }\n}\n\nimpl<'a, Impl: SelectorImpl> Iterator for SelectorIter<'a, Impl> {\n type Item = &'a Component;\n\n #[inline]\n fn next(&mut self) -> Option {\n debug_assert!(\n self.next_combinator.is_none(),\n \"You should call next_sequence!\"\n );\n match *self.iter.next()? {\n Component::Combinator(c) => {\n self.next_combinator = Some(c);\n None\n },\n ref x => Some(x),\n }\n }\n}\n\nimpl<'a, Impl: SelectorImpl> fmt::Debug for SelectorIter<'a, Impl> {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n let iter = self.iter.clone().rev();\n for component in iter {\n component.to_css(f)?\n }\n Ok(())\n }\n}\n\n/// An iterator over all combinators in a selector. Does not traverse selectors within psuedoclasses.\nstruct CombinatorIter<'a, Impl: 'a + SelectorImpl>(SelectorIter<'a, Impl>);\nimpl<'a, Impl: 'a + SelectorImpl> CombinatorIter<'a, Impl> {\n fn new(inner: SelectorIter<'a, Impl>) -> Self {\n let mut result = CombinatorIter(inner);\n result.consume_non_combinators();\n result\n }\n\n fn consume_non_combinators(&mut self) {\n while self.0.next().is_some() {}\n }\n}\n\nimpl<'a, Impl: SelectorImpl> Iterator for CombinatorIter<'a, Impl> {\n type Item = Combinator;\n fn next(&mut self) -> Option {\n let result = self.0.next_sequence();\n self.consume_non_combinators();\n result\n }\n}\n\n/// An iterator over all simple selectors belonging to ancestors.\nstruct AncestorIter<'a, Impl: 'a + SelectorImpl>(SelectorIter<'a, Impl>);\nimpl<'a, Impl: 'a + SelectorImpl> AncestorIter<'a, Impl> {\n /// Creates an AncestorIter. The passed-in iterator is assumed to point to\n /// the beginning of the child sequence, which will be skipped.\n fn new(inner: SelectorIter<'a, Impl>) -> Self {\n let mut result = AncestorIter(inner);\n result.skip_until_ancestor();\n result\n }\n\n /// Skips a sequence of simple selectors and all subsequent sequences until\n /// a non-pseudo-element ancestor combinator is reached.\n fn skip_until_ancestor(&mut self) {\n loop {\n while self.0.next().is_some() {}\n // If this is ever changed to stop at the \"pseudo-element\"\n // combinator, we will need to fix the way we compute hashes for\n // revalidation selectors.\n if self.0.next_sequence().map_or(true, |x| {\n matches!(x, Combinator::Child | Combinator::Descendant)\n }) {\n break;\n }\n }\n }\n}\n\nimpl<'a, Impl: SelectorImpl> Iterator for AncestorIter<'a, Impl> {\n type Item = &'a Component;\n fn next(&mut self) -> Option {\n // Grab the next simple selector in the sequence if available.\n let next = self.0.next();\n if next.is_some() {\n return next;\n }\n\n // See if there are more sequences. If so, skip any non-ancestor sequences.\n if let Some(combinator) = self.0.next_sequence() {\n if !matches!(combinator, Combinator::Child | Combinator::Descendant) {\n self.skip_until_ancestor();\n }\n }\n\n self.0.next()\n }\n}\n\n#[derive(Clone, Copy, Debug, Eq, PartialEq)]\n#[cfg_attr(feature = \"to_shmem\", derive(ToShmem))]\npub enum Combinator {\n Child, // >\n Descendant, // space\n NextSibling, // +\n LaterSibling, // ~\n /// A dummy combinator we use to the left of pseudo-elements.\n ///\n /// It serializes as the empty string, and acts effectively as a child\n /// combinator in most cases. If we ever actually start using a child\n /// combinator for this, we will need to fix up the way hashes are computed\n /// for revalidation selectors.\n PseudoElement,\n /// Another combinator used for ::slotted(), which represent the jump from\n /// a node to its assigned slot.\n SlotAssignment,\n /// Another combinator used for `::part()`, which represents the jump from\n /// the part to the containing shadow host.\n Part,\n}\n\nimpl Combinator {\n /// Returns true if this combinator is a child or descendant combinator.\n #[inline]\n pub fn is_ancestor(&self) -> bool {\n matches!(\n *self,\n Combinator::Child\n | Combinator::Descendant\n | Combinator::PseudoElement\n | Combinator::SlotAssignment\n )\n }\n\n /// Returns true if this combinator is a pseudo-element combinator.\n #[inline]\n pub fn is_pseudo_element(&self) -> bool {\n matches!(*self, Combinator::PseudoElement)\n }\n\n /// Returns true if this combinator is a next- or later-sibling combinator.\n #[inline]\n pub fn is_sibling(&self) -> bool {\n matches!(*self, Combinator::NextSibling | Combinator::LaterSibling)\n }\n}\n\n/// An enum for the different types of :nth- pseudoclasses\n#[derive(Copy, Clone, Eq, PartialEq)]\n#[cfg_attr(feature = \"to_shmem\", derive(ToShmem))]\n#[cfg_attr(feature = \"to_shmem\", shmem(no_bounds))]\npub enum NthType {\n Child,\n LastChild,\n OnlyChild,\n OfType,\n LastOfType,\n OnlyOfType,\n}\n\nimpl NthType {\n pub fn is_only(self) -> bool {\n self == Self::OnlyChild || self == Self::OnlyOfType\n }\n\n pub fn is_of_type(self) -> bool {\n self == Self::OfType || self == Self::LastOfType || self == Self::OnlyOfType\n }\n\n pub fn is_from_end(self) -> bool {\n self == Self::LastChild || self == Self::LastOfType\n }\n}\n\n/// The properties that comprise an An+B syntax\n#[derive(Copy, Clone, Eq, PartialEq, Debug)]\n#[cfg_attr(feature = \"to_shmem\", derive(ToShmem))]\n#[cfg_attr(feature = \"to_shmem\", shmem(no_bounds))]\npub struct AnPlusB(pub i32, pub i32);\n\nimpl AnPlusB {\n #[inline]\n pub fn matches_index(&self, i: i32) -> bool {\n // Is there a non-negative integer n such that An+B=i?\n match i.checked_sub(self.1) {\n None => false,\n Some(an) => match an.checked_div(self.0) {\n Some(n) => n >= 0 && self.0 * n == an,\n None /* a == 0 */ => an == 0,\n },\n }\n }\n}\n\nimpl ToCss for AnPlusB {\n /// Serialize (part of the CSS Syntax spec).\n /// \n #[inline]\n fn to_css(&self, dest: &mut W) -> fmt::Result\n where\n W: fmt::Write,\n {\n match (self.0, self.1) {\n (0, 0) => dest.write_char('0'),\n\n (1, 0) => dest.write_char('n'),\n (-1, 0) => dest.write_str(\"-n\"),\n (_, 0) => write!(dest, \"{}n\", self.0),\n\n (0, _) => write!(dest, \"{}\", self.1),\n (1, _) => write!(dest, \"n{:+}\", self.1),\n (-1, _) => write!(dest, \"-n{:+}\", self.1),\n (_, _) => write!(dest, \"{}n{:+}\", self.0, self.1),\n }\n }\n}\n\n/// The properties that comprise an :nth- pseudoclass as of Selectors 3 (e.g.,\n/// nth-child(An+B)).\n/// https://www.w3.org/TR/selectors-3/#nth-child-pseudo\n#[derive(Copy, Clone, Eq, PartialEq)]\n#[cfg_attr(feature = \"to_shmem\", derive(ToShmem))]\n#[cfg_attr(feature = \"to_shmem\", shmem(no_bounds))]\npub struct NthSelectorData {\n pub ty: NthType,\n pub is_function: bool,\n pub an_plus_b: AnPlusB,\n}\n\nimpl NthSelectorData {\n /// Returns selector data for :only-{child,of-type}\n #[inline]\n pub const fn only(of_type: bool) -> Self {\n Self {\n ty: if of_type {\n NthType::OnlyOfType\n } else {\n NthType::OnlyChild\n },\n is_function: false,\n an_plus_b: AnPlusB(0, 1),\n }\n }\n\n /// Returns selector data for :first-{child,of-type}\n #[inline]\n pub const fn first(of_type: bool) -> Self {\n Self {\n ty: if of_type {\n NthType::OfType\n } else {\n NthType::Child\n },\n is_function: false,\n an_plus_b: AnPlusB(0, 1),\n }\n }\n\n /// Returns selector data for :last-{child,of-type}\n #[inline]\n pub const fn last(of_type: bool) -> Self {\n Self {\n ty: if of_type {\n NthType::LastOfType\n } else {\n NthType::LastChild\n },\n is_function: false,\n an_plus_b: AnPlusB(0, 1),\n }\n }\n\n /// Returns true if this is an edge selector that is not `:*-of-type``\n #[inline]\n pub fn is_simple_edge(&self) -> bool {\n self.an_plus_b.0 == 0\n && self.an_plus_b.1 == 1\n && !self.ty.is_of_type()\n && !self.ty.is_only()\n }\n\n /// Writes the beginning of the selector.\n #[inline]\n fn write_start(&self, dest: &mut W) -> fmt::Result {\n dest.write_str(match self.ty {\n NthType::Child if self.is_function => \":nth-child(\",\n NthType::Child => \":first-child\",\n NthType::LastChild if self.is_function => \":nth-last-child(\",\n NthType::LastChild => \":last-child\",\n NthType::OfType if self.is_function => \":nth-of-type(\",\n NthType::OfType => \":first-of-type\",\n NthType::LastOfType if self.is_function => \":nth-last-of-type(\",\n NthType::LastOfType => \":last-of-type\",\n NthType::OnlyChild => \":only-child\",\n NthType::OnlyOfType => \":only-of-type\",\n })\n }\n\n #[inline]\n fn write_affine(&self, dest: &mut W) -> fmt::Result {\n self.an_plus_b.to_css(dest)\n }\n}\n\n/// The properties that comprise an :nth- pseudoclass as of Selectors 4 (e.g.,\n/// nth-child(An+B [of S]?)).\n/// https://www.w3.org/TR/selectors-4/#nth-child-pseudo\n#[derive(Clone, Eq, PartialEq)]\n#[cfg_attr(feature = \"to_shmem\", derive(ToShmem))]\n#[cfg_attr(feature = \"to_shmem\", shmem(no_bounds))]\npub struct NthOfSelectorData(\n #[cfg_attr(feature = \"to_shmem\", shmem(field_bound))] ThinArc>,\n);\n\nimpl NthOfSelectorData {\n /// Returns selector data for :nth-{,last-}{child,of-type}(An+B [of S])\n #[inline]\n pub fn new(nth_data: &NthSelectorData, selectors: I) -> Self\n where\n I: Iterator> + ExactSizeIterator,\n {\n Self(ThinArc::from_header_and_iter(*nth_data, selectors))\n }\n\n /// Returns the An+B part of the selector\n #[inline]\n pub fn nth_data(&self) -> &NthSelectorData {\n &self.0.header\n }\n\n /// Returns the selector list part of the selector\n #[inline]\n pub fn selectors(&self) -> &[Selector] {\n self.0.slice()\n }\n}\n\n/// Flag indicating where a given relative selector's match would be contained.\n#[derive(Clone, Copy, Eq, PartialEq)]\n#[cfg_attr(feature = \"to_shmem\", derive(ToShmem))]\npub enum RelativeSelectorMatchHint {\n /// Within this element's subtree.\n InSubtree,\n /// Within this element's direct children.\n InChild,\n /// This element's next sibling.\n InNextSibling,\n /// Within this element's next sibling's subtree.\n InNextSiblingSubtree,\n /// Within this element's subsequent siblings.\n InSibling,\n /// Across this element's subsequent siblings and their subtrees.\n InSiblingSubtree,\n}\n\nimpl RelativeSelectorMatchHint {\n /// Create a new relative selector match hint based on its composition.\n pub fn new(\n relative_combinator: Combinator,\n has_child_or_descendants: bool,\n has_adjacent_or_next_siblings: bool,\n ) -> Self {\n match relative_combinator {\n Combinator::Descendant => RelativeSelectorMatchHint::InSubtree,\n Combinator::Child => {\n if !has_child_or_descendants {\n RelativeSelectorMatchHint::InChild\n } else {\n // Technically, for any composition that consists of child combinators only,\n // the search space is depth-constrained, but it's probably not worth optimizing for.\n RelativeSelectorMatchHint::InSubtree\n }\n },\n Combinator::NextSibling => {\n if !has_child_or_descendants && !has_adjacent_or_next_siblings {\n RelativeSelectorMatchHint::InNextSibling\n } else if !has_child_or_descendants && has_adjacent_or_next_siblings {\n RelativeSelectorMatchHint::InSibling\n } else if has_child_or_descendants && !has_adjacent_or_next_siblings {\n // Match won't cross multiple siblings.\n RelativeSelectorMatchHint::InNextSiblingSubtree\n } else {\n RelativeSelectorMatchHint::InSiblingSubtree\n }\n },\n Combinator::LaterSibling => {\n if !has_child_or_descendants {\n RelativeSelectorMatchHint::InSibling\n } else {\n // Even if the match may not cross multiple siblings, we have to look until\n // we find a match anyway.\n RelativeSelectorMatchHint::InSiblingSubtree\n }\n },\n Combinator::Part | Combinator::PseudoElement | Combinator::SlotAssignment => {\n debug_assert!(false, \"Unexpected relative combinator\");\n RelativeSelectorMatchHint::InSubtree\n },\n }\n }\n\n /// Is the match traversal direction towards the descendant of this element (As opposed to siblings)?\n pub fn is_descendant_direction(&self) -> bool {\n matches!(*self, Self::InChild | Self::InSubtree)\n }\n\n /// Is the match traversal terminated at the next sibling?\n pub fn is_next_sibling(&self) -> bool {\n matches!(*self, Self::InNextSibling | Self::InNextSiblingSubtree)\n }\n\n /// Does the match involve matching the subtree?\n pub fn is_subtree(&self) -> bool {\n matches!(\n *self,\n Self::InSubtree | Self::InSiblingSubtree | Self::InNextSiblingSubtree\n )\n }\n}\n\n/// Count of combinators in a given relative selector, not traversing selectors of pseudoclasses.\n#[derive(Clone, Copy)]\npub struct RelativeSelectorCombinatorCount {\n relative_combinator: Combinator,\n pub child_or_descendants: usize,\n pub adjacent_or_next_siblings: usize,\n}\n\nimpl RelativeSelectorCombinatorCount {\n /// Create a new relative selector combinator count from a given relative selector.\n pub fn new(relative_selector: &RelativeSelector) -> Self {\n let mut result = RelativeSelectorCombinatorCount {\n relative_combinator: relative_selector.selector.combinator_at_parse_order(1),\n child_or_descendants: 0,\n adjacent_or_next_siblings: 0,\n };\n\n for combinator in CombinatorIter::new(\n relative_selector\n .selector\n .iter_skip_relative_selector_anchor(),\n ) {\n match combinator {\n Combinator::Descendant | Combinator::Child => {\n result.child_or_descendants += 1;\n },\n Combinator::NextSibling | Combinator::LaterSibling => {\n result.adjacent_or_next_siblings += 1;\n },\n Combinator::Part | Combinator::PseudoElement | Combinator::SlotAssignment => {\n continue;\n },\n };\n }\n result\n }\n\n /// Get the match hint based on the current combinator count.\n pub fn get_match_hint(&self) -> RelativeSelectorMatchHint {\n RelativeSelectorMatchHint::new(\n self.relative_combinator,\n self.child_or_descendants != 0,\n self.adjacent_or_next_siblings != 0,\n )\n }\n}\n\n/// Storage for a relative selector.\n#[derive(Clone, Eq, PartialEq)]\n#[cfg_attr(feature = \"to_shmem\", derive(ToShmem))]\n#[cfg_attr(feature = \"to_shmem\", shmem(no_bounds))]\npub struct RelativeSelector {\n /// Match space constraining hint.\n pub match_hint: RelativeSelectorMatchHint,\n /// The selector. Guaranteed to contain `RelativeSelectorAnchor` and the relative combinator in parse order.\n #[cfg_attr(feature = \"to_shmem\", shmem(field_bound))]\n pub selector: Selector,\n}\n\nbitflags! {\n /// Composition of combinators in a given selector, not traversing selectors of pseudoclasses.\n #[derive(Clone, Debug, Eq, PartialEq)]\n struct CombinatorComposition: u8 {\n const DESCENDANTS = 1 << 0;\n const SIBLINGS = 1 << 1;\n }\n}\n\nimpl CombinatorComposition {\n fn for_relative_selector(inner_selector: &Selector) -> Self {\n let mut result = CombinatorComposition::empty();\n for combinator in CombinatorIter::new(inner_selector.iter_skip_relative_selector_anchor()) {\n match combinator {\n Combinator::Descendant | Combinator::Child => {\n result.insert(Self::DESCENDANTS);\n },\n Combinator::NextSibling | Combinator::LaterSibling => {\n result.insert(Self::SIBLINGS);\n },\n Combinator::Part | Combinator::PseudoElement | Combinator::SlotAssignment => {\n continue;\n },\n };\n if result.is_all() {\n break;\n }\n }\n return result;\n }\n}\n\nimpl RelativeSelector {\n fn from_selector_list(selector_list: SelectorList) -> Box<[Self]> {\n selector_list\n .slice()\n .iter()\n .map(|selector| {\n // It's more efficient to keep track of all this during the parse time, but that seems like a lot of special\n // case handling for what it's worth.\n if cfg!(debug_assertions) {\n let relative_selector_anchor = selector.iter_raw_parse_order_from(0).next();\n debug_assert!(\n relative_selector_anchor.is_some(),\n \"Relative selector is empty\"\n );\n debug_assert!(\n matches!(\n relative_selector_anchor.unwrap(),\n Component::RelativeSelectorAnchor\n ),\n \"Relative selector anchor is missing\"\n );\n }\n // Leave a hint for narrowing down the search space when we're matching.\n let composition = CombinatorComposition::for_relative_selector(&selector);\n let match_hint = RelativeSelectorMatchHint::new(\n selector.combinator_at_parse_order(1),\n composition.intersects(CombinatorComposition::DESCENDANTS),\n composition.intersects(CombinatorComposition::SIBLINGS),\n );\n RelativeSelector {\n match_hint,\n selector: selector.clone(),\n }\n })\n .collect()\n }\n}\n\n/// A CSS simple selector or combinator. We store both in the same enum for\n/// optimal packing and cache performance, see [1].\n///\n/// [1] https://bugzilla.mozilla.org/show_bug.cgi?id=1357973\n#[derive(Clone, Eq, PartialEq)]\n#[cfg_attr(feature = \"to_shmem\", derive(ToShmem))]\n#[cfg_attr(feature = \"to_shmem\", shmem(no_bounds))]\npub enum Component {\n LocalName(LocalName),\n\n ID(#[cfg_attr(feature = \"to_shmem\", shmem(field_bound))] Impl::Identifier),\n Class(#[cfg_attr(feature = \"to_shmem\", shmem(field_bound))] Impl::Identifier),\n\n AttributeInNoNamespaceExists {\n #[cfg_attr(feature = \"to_shmem\", shmem(field_bound))]\n local_name: Impl::LocalName,\n local_name_lower: Impl::LocalName,\n },\n // Used only when local_name is already lowercase.\n AttributeInNoNamespace {\n local_name: Impl::LocalName,\n operator: AttrSelectorOperator,\n #[cfg_attr(feature = \"to_shmem\", shmem(field_bound))]\n value: Impl::AttrValue,\n case_sensitivity: ParsedCaseSensitivity,\n },\n // Use a Box in the less common cases with more data to keep size_of::() small.\n AttributeOther(Box>),\n\n ExplicitUniversalType,\n ExplicitAnyNamespace,\n\n ExplicitNoNamespace,\n DefaultNamespace(#[cfg_attr(feature = \"to_shmem\", shmem(field_bound))] Impl::NamespaceUrl),\n Namespace(\n #[cfg_attr(feature = \"to_shmem\", shmem(field_bound))] Impl::NamespacePrefix,\n #[cfg_attr(feature = \"to_shmem\", shmem(field_bound))] Impl::NamespaceUrl,\n ),\n\n /// Pseudo-classes\n Negation(SelectorList),\n Root,\n Empty,\n Scope,\n /// :scope added implicitly into scoped rules (i.e. In `@scope`) not\n /// explicitly using `:scope` or `&` selectors.\n ///\n /// https://drafts.csswg.org/css-cascade-6/#scoped-rules\n ///\n /// Unlike the normal `:scope` selector, this does not add any specificity.\n /// See https://github.com/w3c/csswg-drafts/issues/10196\n ImplicitScope,\n ParentSelector,\n Nth(NthSelectorData),\n NthOf(NthOfSelectorData),\n NonTSPseudoClass(#[cfg_attr(feature = \"to_shmem\", shmem(field_bound))] Impl::NonTSPseudoClass),\n /// The ::slotted() pseudo-element:\n ///\n /// https://drafts.csswg.org/css-scoping/#slotted-pseudo\n ///\n /// The selector here is a compound selector, that is, no combinators.\n ///\n /// NOTE(emilio): This should support a list of selectors, but as of this\n /// writing no other browser does, and that allows them to put ::slotted()\n /// in the rule hash, so we do that too.\n ///\n /// See https://github.com/w3c/csswg-drafts/issues/2158\n Slotted(Selector),\n /// The `::part` pseudo-element.\n /// https://drafts.csswg.org/css-shadow-parts/#part\n Part(#[cfg_attr(feature = \"to_shmem\", shmem(field_bound))] Box<[Impl::Identifier]>),\n /// The `:host` pseudo-class:\n ///\n /// https://drafts.csswg.org/css-scoping/#host-selector\n ///\n /// NOTE(emilio): This should support a list of selectors, but as of this\n /// writing no other browser does, and that allows them to put :host()\n /// in the rule hash, so we do that too.\n ///\n /// See https://github.com/w3c/csswg-drafts/issues/2158\n Host(Option>),\n /// The `:where` pseudo-class.\n ///\n /// https://drafts.csswg.org/selectors/#zero-matches\n ///\n /// The inner argument is conceptually a SelectorList, but we move the\n /// selectors to the heap to keep Component small.\n Where(SelectorList),\n /// The `:is` pseudo-class.\n ///\n /// https://drafts.csswg.org/selectors/#matches-pseudo\n ///\n /// Same comment as above re. the argument.\n Is(SelectorList),\n /// The `:has` pseudo-class.\n ///\n /// https://drafts.csswg.org/selectors/#has-pseudo\n ///\n /// Same comment as above re. the argument.\n Has(Box<[RelativeSelector]>),\n /// An invalid selector inside :is() / :where().\n Invalid(Arc),\n /// An implementation-dependent pseudo-element selector.\n PseudoElement(#[cfg_attr(feature = \"to_shmem\", shmem(field_bound))] Impl::PseudoElement),\n\n Combinator(Combinator),\n\n /// Used only for relative selectors, which starts with a combinator\n /// (With an implied descendant combinator if not specified).\n ///\n /// https://drafts.csswg.org/selectors-4/#typedef-relative-selector\n RelativeSelectorAnchor,\n}\n\nimpl Component {\n /// Returns true if this is a combinator.\n #[inline]\n pub fn is_combinator(&self) -> bool {\n matches!(*self, Component::Combinator(_))\n }\n\n /// Returns true if this is a :host() selector.\n #[inline]\n pub fn is_host(&self) -> bool {\n matches!(*self, Component::Host(..))\n }\n\n /// Returns the value as a combinator if applicable, None otherwise.\n pub fn as_combinator(&self) -> Option {\n match *self {\n Component::Combinator(c) => Some(c),\n _ => None,\n }\n }\n\n /// Whether a given selector (to the right of a pseudo-element) should match for stateless\n /// pseudo-elements. Note that generally nothing matches for those, but since we have :not(),\n /// we still need to traverse nested selector lists.\n fn matches_for_stateless_pseudo_element(&self) -> bool {\n match *self {\n Component::Negation(ref selectors) => !selectors.slice().iter().all(|selector| {\n selector\n .iter_raw_match_order()\n .all(|c| c.matches_for_stateless_pseudo_element())\n }),\n Component::Is(ref selectors) | Component::Where(ref selectors) => {\n selectors.slice().iter().any(|selector| {\n selector\n .iter_raw_match_order()\n .all(|c| c.matches_for_stateless_pseudo_element())\n })\n },\n _ => false,\n }\n }\n\n pub fn visit(&self, visitor: &mut V) -> bool\n where\n V: SelectorVisitor,\n {\n use self::Component::*;\n if !visitor.visit_simple_selector(self) {\n return false;\n }\n\n match *self {\n Slotted(ref selector) => {\n if !selector.visit(visitor) {\n return false;\n }\n },\n Host(Some(ref selector)) => {\n if !selector.visit(visitor) {\n return false;\n }\n },\n AttributeInNoNamespaceExists {\n ref local_name,\n ref local_name_lower,\n } => {\n if !visitor.visit_attribute_selector(\n &NamespaceConstraint::Specific(&namespace_empty_string::()),\n local_name,\n local_name_lower,\n ) {\n return false;\n }\n },\n AttributeInNoNamespace { ref local_name, .. } => {\n if !visitor.visit_attribute_selector(\n &NamespaceConstraint::Specific(&namespace_empty_string::()),\n local_name,\n local_name,\n ) {\n return false;\n }\n },\n AttributeOther(ref attr_selector) => {\n let empty_string;\n let namespace = match attr_selector.namespace() {\n Some(ns) => ns,\n None => {\n empty_string = crate::parser::namespace_empty_string::();\n NamespaceConstraint::Specific(&empty_string)\n },\n };\n if !visitor.visit_attribute_selector(\n &namespace,\n &attr_selector.local_name,\n &attr_selector.local_name_lower,\n ) {\n return false;\n }\n },\n\n NonTSPseudoClass(ref pseudo_class) => {\n if !pseudo_class.visit(visitor) {\n return false;\n }\n },\n Negation(ref list) | Is(ref list) | Where(ref list) => {\n let list_kind = SelectorListKind::from_component(self);\n debug_assert!(!list_kind.is_empty());\n if !visitor.visit_selector_list(list_kind, list.slice()) {\n return false;\n }\n },\n NthOf(ref nth_of_data) => {\n if !visitor.visit_selector_list(SelectorListKind::NTH_OF, nth_of_data.selectors()) {\n return false;\n }\n },\n Has(ref list) => {\n if !visitor.visit_relative_selector_list(list) {\n return false;\n }\n },\n _ => {},\n }\n\n true\n }\n\n // Returns true if this has any selector that requires an index calculation. e.g.\n // :nth-child, :first-child, etc. For nested selectors, return true only if the\n // indexed selector is in its subject compound.\n pub fn has_indexed_selector_in_subject(&self) -> bool {\n match *self {\n Component::NthOf(..) | Component::Nth(..) => return true,\n Component::Is(ref selectors)\n | Component::Where(ref selectors)\n | Component::Negation(ref selectors) => {\n // Check the subject compound.\n for selector in selectors.slice() {\n let mut iter = selector.iter();\n while let Some(c) = iter.next() {\n if c.has_indexed_selector_in_subject() {\n return true;\n }\n }\n }\n },\n _ => (),\n };\n false\n }\n}\n\n#[derive(Clone, Eq, PartialEq)]\n#[cfg_attr(feature = \"to_shmem\", derive(ToShmem))]\n#[cfg_attr(feature = \"to_shmem\", shmem(no_bounds))]\npub struct LocalName {\n #[cfg_attr(feature = \"to_shmem\", shmem(field_bound))]\n pub name: Impl::LocalName,\n pub lower_name: Impl::LocalName,\n}\n\nimpl Debug for Selector {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n f.write_str(\"Selector(\")?;\n self.to_css(f)?;\n write!(\n f,\n \", specificity = {:#x}, flags = {:?})\",\n self.specificity(),\n self.flags()\n )\n }\n}\n\nimpl Debug for Component {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n self.to_css(f)\n }\n}\nimpl Debug for AttrSelectorWithOptionalNamespace {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n self.to_css(f)\n }\n}\nimpl Debug for LocalName {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n self.to_css(f)\n }\n}\n\nfn serialize_selector_list<'a, Impl, I, W>(iter: I, dest: &mut W) -> fmt::Result\nwhere\n Impl: SelectorImpl,\n I: Iterator>,\n W: fmt::Write,\n{\n let mut first = true;\n for selector in iter {\n if !first {\n dest.write_str(\", \")?;\n }\n first = false;\n selector.to_css(dest)?;\n }\n Ok(())\n}\n\nimpl ToCss for SelectorList {\n fn to_css(&self, dest: &mut W) -> fmt::Result\n where\n W: fmt::Write,\n {\n serialize_selector_list(self.slice().iter(), dest)\n }\n}\n\nimpl ToCss for Selector {\n fn to_css(&self, dest: &mut W) -> fmt::Result\n where\n W: fmt::Write,\n {\n // Compound selectors invert the order of their contents, so we need to\n // undo that during serialization.\n //\n // This two-iterator strategy involves walking over the selector twice.\n // We could do something more clever, but selector serialization probably\n // isn't hot enough to justify it, and the stringification likely\n // dominates anyway.\n //\n // NB: A parse-order iterator is a Rev<>, which doesn't expose as_slice(),\n // which we need for |split|. So we split by combinators on a match-order\n // sequence and then reverse.\n\n let mut combinators = self\n .iter_raw_match_order()\n .rev()\n .filter_map(|x| x.as_combinator());\n let compound_selectors = self\n .iter_raw_match_order()\n .as_slice()\n .split(|x| x.is_combinator())\n .rev();\n\n let mut combinators_exhausted = false;\n for compound in compound_selectors {\n debug_assert!(!combinators_exhausted);\n\n // https://drafts.csswg.org/cssom/#serializing-selectors\n let first_compound = match compound.first() {\n None => continue,\n Some(c) => c,\n };\n if matches!(\n first_compound,\n Component::RelativeSelectorAnchor | Component::ImplicitScope\n ) {\n debug_assert!(\n compound.len() == 1,\n \"RelativeSelectorAnchor/ImplicitScope should only be a simple selector\"\n );\n if let Some(c) = combinators.next() {\n c.to_css_relative(dest)?;\n } else {\n // Direct property declarations in `@scope` does not have\n // combinators, since its selector is `:implicit-scope`.\n debug_assert!(\n matches!(first_compound, Component::ImplicitScope),\n \"Only implicit :scope may not have any combinator\"\n );\n }\n continue;\n }\n\n // 1. If there is only one simple selector in the compound selectors\n // which is a universal selector, append the result of\n // serializing the universal selector to s.\n //\n // Check if `!compound.empty()` first--this can happen if we have\n // something like `... > ::before`, because we store `>` and `::`\n // both as combinators internally.\n //\n // If we are in this case, after we have serialized the universal\n // selector, we skip Step 2 and continue with the algorithm.\n let (can_elide_namespace, first_non_namespace) = match compound[0] {\n Component::ExplicitAnyNamespace\n | Component::ExplicitNoNamespace\n | Component::Namespace(..) => (false, 1),\n Component::DefaultNamespace(..) => (true, 1),\n _ => (true, 0),\n };\n let mut perform_step_2 = true;\n let next_combinator = combinators.next();\n if first_non_namespace == compound.len() - 1 {\n match (next_combinator, &compound[first_non_namespace]) {\n // We have to be careful here, because if there is a\n // pseudo element \"combinator\" there isn't really just\n // the one simple selector. Technically this compound\n // selector contains the pseudo element selector as well\n // -- Combinator::PseudoElement, just like\n // Combinator::SlotAssignment, don't exist in the\n // spec.\n (Some(Combinator::PseudoElement), _)\n | (Some(Combinator::SlotAssignment), _) => (),\n (_, &Component::ExplicitUniversalType) => {\n // Iterate over everything so we serialize the namespace\n // too.\n for simple in compound.iter() {\n simple.to_css(dest)?;\n }\n // Skip step 2, which is an \"otherwise\".\n perform_step_2 = false;\n },\n _ => (),\n }\n }\n\n // 2. Otherwise, for each simple selector in the compound selectors\n // that is not a universal selector of which the namespace prefix\n // maps to a namespace that is not the default namespace\n // serialize the simple selector and append the result to s.\n //\n // See https://github.com/w3c/csswg-drafts/issues/1606, which is\n // proposing to change this to match up with the behavior asserted\n // in cssom/serialize-namespaced-type-selectors.html, which the\n // following code tries to match.\n if perform_step_2 {\n for simple in compound.iter() {\n if let Component::ExplicitUniversalType = *simple {\n // Can't have a namespace followed by a pseudo-element\n // selector followed by a universal selector in the same\n // compound selector, so we don't have to worry about the\n // real namespace being in a different `compound`.\n if can_elide_namespace {\n continue;\n }\n }\n simple.to_css(dest)?;\n }\n }\n\n // 3. If this is not the last part of the chain of the selector\n // append a single SPACE (U+0020), followed by the combinator\n // \">\", \"+\", \"~\", \">>\", \"||\", as appropriate, followed by another\n // single SPACE (U+0020) if the combinator was not whitespace, to\n // s.\n match next_combinator {\n Some(c) => c.to_css(dest)?,\n None => combinators_exhausted = true,\n };\n\n // 4. If this is the last part of the chain of the selector and\n // there is a pseudo-element, append \"::\" followed by the name of\n // the pseudo-element, to s.\n //\n // (we handle this above)\n }\n\n Ok(())\n }\n}\n\nimpl Combinator {\n fn to_css_internal(&self, dest: &mut W, prefix_space: bool) -> fmt::Result\n where\n W: fmt::Write,\n {\n if matches!(\n *self,\n Combinator::PseudoElement | Combinator::Part | Combinator::SlotAssignment\n ) {\n return Ok(());\n }\n if prefix_space {\n dest.write_char(' ')?;\n }\n match *self {\n Combinator::Child => dest.write_str(\"> \"),\n Combinator::Descendant => Ok(()),\n Combinator::NextSibling => dest.write_str(\"+ \"),\n Combinator::LaterSibling => dest.write_str(\"~ \"),\n Combinator::PseudoElement | Combinator::Part | Combinator::SlotAssignment => unsafe {\n debug_unreachable!(\"Already handled\")\n },\n }\n }\n\n fn to_css_relative(&self, dest: &mut W) -> fmt::Result\n where\n W: fmt::Write,\n {\n self.to_css_internal(dest, false)\n }\n}\n\nimpl ToCss for Combinator {\n fn to_css(&self, dest: &mut W) -> fmt::Result\n where\n W: fmt::Write,\n {\n self.to_css_internal(dest, true)\n }\n}\n\nimpl ToCss for Component {\n fn to_css(&self, dest: &mut W) -> fmt::Result\n where\n W: fmt::Write,\n {\n use self::Component::*;\n\n match *self {\n Combinator(ref c) => c.to_css(dest),\n Slotted(ref selector) => {\n dest.write_str(\"::slotted(\")?;\n selector.to_css(dest)?;\n dest.write_char(')')\n },\n Part(ref part_names) => {\n dest.write_str(\"::part(\")?;\n for (i, name) in part_names.iter().enumerate() {\n if i != 0 {\n dest.write_char(' ')?;\n }\n name.to_css(dest)?;\n }\n dest.write_char(')')\n },\n PseudoElement(ref p) => p.to_css(dest),\n ID(ref s) => {\n dest.write_char('#')?;\n s.to_css(dest)\n },\n Class(ref s) => {\n dest.write_char('.')?;\n s.to_css(dest)\n },\n LocalName(ref s) => s.to_css(dest),\n ExplicitUniversalType => dest.write_char('*'),\n\n DefaultNamespace(_) => Ok(()),\n ExplicitNoNamespace => dest.write_char('|'),\n ExplicitAnyNamespace => dest.write_str(\"*|\"),\n Namespace(ref prefix, _) => {\n prefix.to_css(dest)?;\n dest.write_char('|')\n },\n\n AttributeInNoNamespaceExists { ref local_name, .. } => {\n dest.write_char('[')?;\n local_name.to_css(dest)?;\n dest.write_char(']')\n },\n AttributeInNoNamespace {\n ref local_name,\n operator,\n ref value,\n case_sensitivity,\n ..\n } => {\n dest.write_char('[')?;\n local_name.to_css(dest)?;\n operator.to_css(dest)?;\n value.to_css(dest)?;\n match case_sensitivity {\n ParsedCaseSensitivity::CaseSensitive\n | ParsedCaseSensitivity::AsciiCaseInsensitiveIfInHtmlElementInHtmlDocument => {\n },\n ParsedCaseSensitivity::AsciiCaseInsensitive => dest.write_str(\" i\")?,\n ParsedCaseSensitivity::ExplicitCaseSensitive => dest.write_str(\" s\")?,\n }\n dest.write_char(']')\n },\n AttributeOther(ref attr_selector) => attr_selector.to_css(dest),\n\n // Pseudo-classes\n Root => dest.write_str(\":root\"),\n Empty => dest.write_str(\":empty\"),\n Scope => dest.write_str(\":scope\"),\n ParentSelector => dest.write_char('&'),\n Host(ref selector) => {\n dest.write_str(\":host\")?;\n if let Some(ref selector) = *selector {\n dest.write_char('(')?;\n selector.to_css(dest)?;\n dest.write_char(')')?;\n }\n Ok(())\n },\n Nth(ref nth_data) => {\n nth_data.write_start(dest)?;\n if nth_data.is_function {\n nth_data.write_affine(dest)?;\n dest.write_char(')')?;\n }\n Ok(())\n },\n NthOf(ref nth_of_data) => {\n let nth_data = nth_of_data.nth_data();\n nth_data.write_start(dest)?;\n debug_assert!(\n nth_data.is_function,\n \"A selector must be a function to hold An+B notation\"\n );\n nth_data.write_affine(dest)?;\n debug_assert!(\n matches!(nth_data.ty, NthType::Child | NthType::LastChild),\n \"Only :nth-child or :nth-last-child can be of a selector list\"\n );\n debug_assert!(\n !nth_of_data.selectors().is_empty(),\n \"The selector list should not be empty\"\n );\n dest.write_str(\" of \")?;\n serialize_selector_list(nth_of_data.selectors().iter(), dest)?;\n dest.write_char(')')\n },\n Is(ref list) | Where(ref list) | Negation(ref list) => {\n match *self {\n Where(..) => dest.write_str(\":where(\")?,\n Is(..) => dest.write_str(\":is(\")?,\n Negation(..) => dest.write_str(\":not(\")?,\n _ => unreachable!(),\n }\n serialize_selector_list(list.slice().iter(), dest)?;\n dest.write_str(\")\")\n },\n Has(ref list) => {\n dest.write_str(\":has(\")?;\n serialize_selector_list(list.iter().map(|rel| &rel.selector), dest)?;\n dest.write_str(\")\")\n },\n NonTSPseudoClass(ref pseudo) => pseudo.to_css(dest),\n Invalid(ref css) => dest.write_str(css),\n RelativeSelectorAnchor | ImplicitScope => Ok(()),\n }\n }\n}\n\nimpl ToCss for AttrSelectorWithOptionalNamespace {\n fn to_css(&self, dest: &mut W) -> fmt::Result\n where\n W: fmt::Write,\n {\n dest.write_char('[')?;\n match self.namespace {\n Some(NamespaceConstraint::Specific((ref prefix, _))) => {\n prefix.to_css(dest)?;\n dest.write_char('|')?\n },\n Some(NamespaceConstraint::Any) => dest.write_str(\"*|\")?,\n None => {},\n }\n self.local_name.to_css(dest)?;\n match self.operation {\n ParsedAttrSelectorOperation::Exists => {},\n ParsedAttrSelectorOperation::WithValue {\n operator,\n case_sensitivity,\n ref value,\n } => {\n operator.to_css(dest)?;\n value.to_css(dest)?;\n match case_sensitivity {\n ParsedCaseSensitivity::CaseSensitive\n | ParsedCaseSensitivity::AsciiCaseInsensitiveIfInHtmlElementInHtmlDocument => {\n },\n ParsedCaseSensitivity::AsciiCaseInsensitive => dest.write_str(\" i\")?,\n ParsedCaseSensitivity::ExplicitCaseSensitive => dest.write_str(\" s\")?,\n }\n },\n }\n dest.write_char(']')\n }\n}\n\nimpl ToCss for LocalName {\n fn to_css(&self, dest: &mut W) -> fmt::Result\n where\n W: fmt::Write,\n {\n self.name.to_css(dest)\n }\n}\n\n/// Build up a Selector.\n/// selector : simple_selector_sequence [ combinator simple_selector_sequence ]* ;\n///\n/// `Err` means invalid selector.\nfn parse_selector<'i, 't, P, Impl>(\n parser: &P,\n input: &mut CssParser<'i, 't>,\n mut state: SelectorParsingState,\n parse_relative: ParseRelative,\n) -> Result, ParseError<'i, P::Error>>\nwhere\n P: Parser<'i, Impl = Impl>,\n Impl: SelectorImpl,\n{\n let mut builder = SelectorBuilder::default();\n\n // Helps rewind less, but also simplifies dealing with relative combinators below.\n input.skip_whitespace();\n\n if parse_relative != ParseRelative::No {\n let combinator = try_parse_combinator(input);\n match parse_relative {\n ParseRelative::ForHas => {\n builder.push_simple_selector(Component::RelativeSelectorAnchor);\n // Do we see a combinator? If so, push that. Otherwise, push a descendant\n // combinator.\n builder.push_combinator(combinator.unwrap_or(Combinator::Descendant));\n },\n ParseRelative::ForNesting | ParseRelative::ForScope => {\n if let Ok(combinator) = combinator {\n let selector = match parse_relative {\n ParseRelative::ForHas | ParseRelative::No => unreachable!(),\n ParseRelative::ForNesting => Component::ParentSelector,\n // See https://github.com/w3c/csswg-drafts/issues/10196\n // Implicitly added `:scope` does not add specificity\n // for non-relative selectors, so do the same.\n ParseRelative::ForScope => Component::ImplicitScope,\n };\n builder.push_simple_selector(selector);\n builder.push_combinator(combinator);\n }\n },\n ParseRelative::No => unreachable!(),\n }\n }\n loop {\n // Parse a sequence of simple selectors.\n let empty = parse_compound_selector(parser, &mut state, input, &mut builder)?;\n if empty {\n return Err(input.new_custom_error(if builder.has_combinators() {\n SelectorParseErrorKind::DanglingCombinator\n } else {\n SelectorParseErrorKind::EmptySelector\n }));\n }\n\n if state.intersects(SelectorParsingState::AFTER_PSEUDO) {\n debug_assert!(state.intersects(\n SelectorParsingState::AFTER_NON_ELEMENT_BACKED_PSEUDO\n | SelectorParsingState::AFTER_BEFORE_OR_AFTER_PSEUDO\n | SelectorParsingState::AFTER_SLOTTED\n | SelectorParsingState::AFTER_PART_LIKE\n ));\n break;\n }\n\n let combinator = if let Ok(c) = try_parse_combinator(input) {\n c\n } else {\n break;\n };\n\n if !state.allows_combinators() {\n return Err(input.new_custom_error(SelectorParseErrorKind::InvalidState));\n }\n\n builder.push_combinator(combinator);\n }\n return Ok(Selector(builder.build(parse_relative)));\n}\n\nfn try_parse_combinator<'i, 't>(input: &mut CssParser<'i, 't>) -> Result {\n let mut any_whitespace = false;\n loop {\n let before_this_token = input.state();\n match input.next_including_whitespace() {\n Err(_e) => return Err(()),\n Ok(&Token::WhiteSpace(_)) => any_whitespace = true,\n Ok(&Token::Delim('>')) => {\n return Ok(Combinator::Child);\n },\n Ok(&Token::Delim('+')) => {\n return Ok(Combinator::NextSibling);\n },\n Ok(&Token::Delim('~')) => {\n return Ok(Combinator::LaterSibling);\n },\n Ok(_) => {\n input.reset(&before_this_token);\n if any_whitespace {\n return Ok(Combinator::Descendant);\n } else {\n return Err(());\n }\n },\n }\n }\n}\n\n/// * `Err(())`: Invalid selector, abort\n/// * `Ok(false)`: Not a type selector, could be something else. `input` was not consumed.\n/// * `Ok(true)`: Length 0 (`*|*`), 1 (`*|E` or `ns|*`) or 2 (`|E` or `ns|E`)\nfn parse_type_selector<'i, 't, P, Impl, S>(\n parser: &P,\n input: &mut CssParser<'i, 't>,\n state: SelectorParsingState,\n sink: &mut S,\n) -> Result>\nwhere\n P: Parser<'i, Impl = Impl>,\n Impl: SelectorImpl,\n S: Push>,\n{\n match parse_qualified_name(parser, input, /* in_attr_selector = */ false) {\n Err(ParseError {\n kind: ParseErrorKind::Basic(BasicParseErrorKind::EndOfInput),\n ..\n })\n | Ok(OptionalQName::None(_)) => Ok(false),\n Ok(OptionalQName::Some(namespace, local_name)) => {\n if state.intersects(SelectorParsingState::AFTER_PSEUDO) {\n return Err(input.new_custom_error(SelectorParseErrorKind::InvalidState));\n }\n match namespace {\n QNamePrefix::ImplicitAnyNamespace => {},\n QNamePrefix::ImplicitDefaultNamespace(url) => {\n sink.push(Component::DefaultNamespace(url))\n },\n QNamePrefix::ExplicitNamespace(prefix, url) => {\n sink.push(match parser.default_namespace() {\n Some(ref default_url) if url == *default_url => {\n Component::DefaultNamespace(url)\n },\n _ => Component::Namespace(prefix, url),\n })\n },\n QNamePrefix::ExplicitNoNamespace => sink.push(Component::ExplicitNoNamespace),\n QNamePrefix::ExplicitAnyNamespace => {\n match parser.default_namespace() {\n // Element type selectors that have no namespace\n // component (no namespace separator) represent elements\n // without regard to the element's namespace (equivalent\n // to \"*|\") unless a default namespace has been declared\n // for namespaced selectors (e.g. in CSS, in the style\n // sheet). If a default namespace has been declared,\n // such selectors will represent only elements in the\n // default namespace.\n // -- Selectors § 6.1.1\n // So we'll have this act the same as the\n // QNamePrefix::ImplicitAnyNamespace case.\n None => {},\n Some(_) => sink.push(Component::ExplicitAnyNamespace),\n }\n },\n QNamePrefix::ImplicitNoNamespace => {\n unreachable!() // Not returned with in_attr_selector = false\n },\n }\n match local_name {\n Some(name) => sink.push(Component::LocalName(LocalName {\n lower_name: to_ascii_lowercase(&name).as_ref().into(),\n name: name.as_ref().into(),\n })),\n None => sink.push(Component::ExplicitUniversalType),\n }\n Ok(true)\n },\n Err(e) => Err(e),\n }\n}\n\n#[derive(Debug)]\nenum SimpleSelectorParseResult {\n SimpleSelector(Component),\n PseudoElement(Impl::PseudoElement),\n SlottedPseudo(Selector),\n PartPseudo(Box<[Impl::Identifier]>),\n}\n\n#[derive(Debug)]\nenum QNamePrefix {\n ImplicitNoNamespace, // `foo` in attr selectors\n ImplicitAnyNamespace, // `foo` in type selectors, without a default ns\n ImplicitDefaultNamespace(Impl::NamespaceUrl), // `foo` in type selectors, with a default ns\n ExplicitNoNamespace, // `|foo`\n ExplicitAnyNamespace, // `*|foo`\n ExplicitNamespace(Impl::NamespacePrefix, Impl::NamespaceUrl), // `prefix|foo`\n}\n\nenum OptionalQName<'i, Impl: SelectorImpl> {\n Some(QNamePrefix, Option>),\n None(Token<'i>),\n}\n\n/// * `Err(())`: Invalid selector, abort\n/// * `Ok(None(token))`: Not a simple selector, could be something else. `input` was not consumed,\n/// but the token is still returned.\n/// * `Ok(Some(namespace, local_name))`: `None` for the local name means a `*` universal selector\nfn parse_qualified_name<'i, 't, P, Impl>(\n parser: &P,\n input: &mut CssParser<'i, 't>,\n in_attr_selector: bool,\n) -> Result, ParseError<'i, P::Error>>\nwhere\n P: Parser<'i, Impl = Impl>,\n Impl: SelectorImpl,\n{\n let default_namespace = |local_name| {\n let namespace = match parser.default_namespace() {\n Some(url) => QNamePrefix::ImplicitDefaultNamespace(url),\n None => QNamePrefix::ImplicitAnyNamespace,\n };\n Ok(OptionalQName::Some(namespace, local_name))\n };\n\n let explicit_namespace = |input: &mut CssParser<'i, 't>, namespace| {\n let location = input.current_source_location();\n match input.next_including_whitespace() {\n Ok(&Token::Delim('*')) if !in_attr_selector => Ok(OptionalQName::Some(namespace, None)),\n Ok(&Token::Ident(ref local_name)) => {\n Ok(OptionalQName::Some(namespace, Some(local_name.clone())))\n },\n Ok(t) if in_attr_selector => {\n let e = SelectorParseErrorKind::InvalidQualNameInAttr(t.clone());\n Err(location.new_custom_error(e))\n },\n Ok(t) => Err(location.new_custom_error(\n SelectorParseErrorKind::ExplicitNamespaceUnexpectedToken(t.clone()),\n )),\n Err(e) => Err(e.into()),\n }\n };\n\n let start = input.state();\n match input.next_including_whitespace() {\n Ok(Token::Ident(value)) => {\n let value = value.clone();\n let after_ident = input.state();\n match input.next_including_whitespace() {\n Ok(&Token::Delim('|')) => {\n let prefix = value.as_ref().into();\n let result = parser.namespace_for_prefix(&prefix);\n let url = result.ok_or(\n after_ident\n .source_location()\n .new_custom_error(SelectorParseErrorKind::ExpectedNamespace(value)),\n )?;\n explicit_namespace(input, QNamePrefix::ExplicitNamespace(prefix, url))\n },\n _ => {\n input.reset(&after_ident);\n if in_attr_selector {\n Ok(OptionalQName::Some(\n QNamePrefix::ImplicitNoNamespace,\n Some(value),\n ))\n } else {\n default_namespace(Some(value))\n }\n },\n }\n },\n Ok(Token::Delim('*')) => {\n let after_star = input.state();\n match input.next_including_whitespace() {\n Ok(&Token::Delim('|')) => {\n explicit_namespace(input, QNamePrefix::ExplicitAnyNamespace)\n },\n _ if !in_attr_selector => {\n input.reset(&after_star);\n default_namespace(None)\n },\n result => {\n let t = result?;\n Err(after_star\n .source_location()\n .new_custom_error(SelectorParseErrorKind::ExpectedBarInAttr(t.clone())))\n },\n }\n },\n Ok(Token::Delim('|')) => explicit_namespace(input, QNamePrefix::ExplicitNoNamespace),\n Ok(t) => {\n let t = t.clone();\n input.reset(&start);\n Ok(OptionalQName::None(t))\n },\n Err(e) => {\n input.reset(&start);\n Err(e.into())\n },\n }\n}\n\nfn parse_attribute_selector<'i, 't, P, Impl>(\n parser: &P,\n input: &mut CssParser<'i, 't>,\n) -> Result, ParseError<'i, P::Error>>\nwhere\n P: Parser<'i, Impl = Impl>,\n Impl: SelectorImpl,\n{\n let namespace;\n let local_name;\n\n input.skip_whitespace();\n\n match parse_qualified_name(parser, input, /* in_attr_selector = */ true)? {\n OptionalQName::None(t) => {\n return Err(input.new_custom_error(\n SelectorParseErrorKind::NoQualifiedNameInAttributeSelector(t),\n ));\n },\n OptionalQName::Some(_, None) => unreachable!(),\n OptionalQName::Some(ns, Some(ln)) => {\n local_name = ln;\n namespace = match ns {\n QNamePrefix::ImplicitNoNamespace | QNamePrefix::ExplicitNoNamespace => None,\n QNamePrefix::ExplicitNamespace(prefix, url) => {\n Some(NamespaceConstraint::Specific((prefix, url)))\n },\n QNamePrefix::ExplicitAnyNamespace => Some(NamespaceConstraint::Any),\n QNamePrefix::ImplicitAnyNamespace | QNamePrefix::ImplicitDefaultNamespace(_) => {\n unreachable!() // Not returned with in_attr_selector = true\n },\n }\n },\n }\n\n let location = input.current_source_location();\n let operator = match input.next() {\n // [foo]\n Err(_) => {\n let local_name_lower = to_ascii_lowercase(&local_name).as_ref().into();\n let local_name = local_name.as_ref().into();\n if let Some(namespace) = namespace {\n return Ok(Component::AttributeOther(Box::new(\n AttrSelectorWithOptionalNamespace {\n namespace: Some(namespace),\n local_name,\n local_name_lower,\n operation: ParsedAttrSelectorOperation::Exists,\n },\n )));\n } else {\n return Ok(Component::AttributeInNoNamespaceExists {\n local_name,\n local_name_lower,\n });\n }\n },\n\n // [foo=bar]\n Ok(&Token::Delim('=')) => AttrSelectorOperator::Equal,\n // [foo~=bar]\n Ok(&Token::IncludeMatch) => AttrSelectorOperator::Includes,\n // [foo|=bar]\n Ok(&Token::DashMatch) => AttrSelectorOperator::DashMatch,\n // [foo^=bar]\n Ok(&Token::PrefixMatch) => AttrSelectorOperator::Prefix,\n // [foo*=bar]\n Ok(&Token::SubstringMatch) => AttrSelectorOperator::Substring,\n // [foo$=bar]\n Ok(&Token::SuffixMatch) => AttrSelectorOperator::Suffix,\n Ok(t) => {\n return Err(location.new_custom_error(\n SelectorParseErrorKind::UnexpectedTokenInAttributeSelector(t.clone()),\n ));\n },\n };\n\n let value = match input.expect_ident_or_string() {\n Ok(t) => t.clone(),\n Err(BasicParseError {\n kind: BasicParseErrorKind::UnexpectedToken(t),\n location,\n }) => return Err(location.new_custom_error(SelectorParseErrorKind::BadValueInAttr(t))),\n Err(e) => return Err(e.into()),\n };\n\n let attribute_flags = parse_attribute_flags(input)?;\n let value = value.as_ref().into();\n let local_name_lower;\n let local_name_is_ascii_lowercase;\n let case_sensitivity;\n {\n let local_name_lower_cow = to_ascii_lowercase(&local_name);\n case_sensitivity =\n attribute_flags.to_case_sensitivity(local_name_lower_cow.as_ref(), namespace.is_some());\n local_name_lower = local_name_lower_cow.as_ref().into();\n local_name_is_ascii_lowercase = matches!(local_name_lower_cow, Cow::Borrowed(..));\n }\n let local_name = local_name.as_ref().into();\n if namespace.is_some() || !local_name_is_ascii_lowercase {\n Ok(Component::AttributeOther(Box::new(\n AttrSelectorWithOptionalNamespace {\n namespace,\n local_name,\n local_name_lower,\n operation: ParsedAttrSelectorOperation::WithValue {\n operator,\n case_sensitivity,\n value,\n },\n },\n )))\n } else {\n Ok(Component::AttributeInNoNamespace {\n local_name,\n operator,\n value,\n case_sensitivity,\n })\n }\n}\n\n/// An attribute selector can have 's' or 'i' as flags, or no flags at all.\nenum AttributeFlags {\n // Matching should be case-sensitive ('s' flag).\n CaseSensitive,\n // Matching should be case-insensitive ('i' flag).\n AsciiCaseInsensitive,\n // No flags. Matching behavior depends on the name of the attribute.\n CaseSensitivityDependsOnName,\n}\n\nimpl AttributeFlags {\n fn to_case_sensitivity(\n self,\n local_name_lower: &str,\n have_namespace: bool,\n ) -> ParsedCaseSensitivity {\n match self {\n AttributeFlags::CaseSensitive => ParsedCaseSensitivity::ExplicitCaseSensitive,\n AttributeFlags::AsciiCaseInsensitive => ParsedCaseSensitivity::AsciiCaseInsensitive,\n AttributeFlags::CaseSensitivityDependsOnName => {\n if !have_namespace\n && include!(concat!(\n env!(\"OUT_DIR\"),\n \"/ascii_case_insensitive_html_attributes.rs\"\n ))\n .contains(local_name_lower)\n {\n ParsedCaseSensitivity::AsciiCaseInsensitiveIfInHtmlElementInHtmlDocument\n } else {\n ParsedCaseSensitivity::CaseSensitive\n }\n },\n }\n }\n}\n\nfn parse_attribute_flags<'i, 't>(\n input: &mut CssParser<'i, 't>,\n) -> Result> {\n let location = input.current_source_location();\n let token = match input.next() {\n Ok(t) => t,\n Err(..) => {\n // Selectors spec says language-defined; HTML says it depends on the\n // exact attribute name.\n return Ok(AttributeFlags::CaseSensitivityDependsOnName);\n },\n };\n\n let ident = match *token {\n Token::Ident(ref i) => i,\n ref other => return Err(location.new_basic_unexpected_token_error(other.clone())),\n };\n\n Ok(match_ignore_ascii_case! {\n ident,\n \"i\" => AttributeFlags::AsciiCaseInsensitive,\n \"s\" => AttributeFlags::CaseSensitive,\n _ => return Err(location.new_basic_unexpected_token_error(token.clone())),\n })\n}\n\n/// Level 3: Parse **one** simple_selector. (Though we might insert a second\n/// implied \"|*\" type selector.)\nfn parse_negation<'i, 't, P, Impl>(\n parser: &P,\n input: &mut CssParser<'i, 't>,\n state: SelectorParsingState,\n) -> Result, ParseError<'i, P::Error>>\nwhere\n P: Parser<'i, Impl = Impl>,\n Impl: SelectorImpl,\n{\n let list = SelectorList::parse_with_state(\n parser,\n input,\n state\n | SelectorParsingState::SKIP_DEFAULT_NAMESPACE\n | SelectorParsingState::DISALLOW_PSEUDOS,\n ForgivingParsing::No,\n ParseRelative::No,\n )?;\n\n Ok(Component::Negation(list))\n}\n\n/// simple_selector_sequence\n/// : [ type_selector | universal ] [ HASH | class | attrib | pseudo | negation ]*\n/// | [ HASH | class | attrib | pseudo | negation ]+\n///\n/// `Err(())` means invalid selector.\n/// `Ok(true)` is an empty selector\nfn parse_compound_selector<'i, 't, P, Impl>(\n parser: &P,\n state: &mut SelectorParsingState,\n input: &mut CssParser<'i, 't>,\n builder: &mut SelectorBuilder,\n) -> Result>\nwhere\n P: Parser<'i, Impl = Impl>,\n Impl: SelectorImpl,\n{\n input.skip_whitespace();\n\n let mut empty = true;\n if parse_type_selector(parser, input, *state, builder)? {\n empty = false;\n }\n\n loop {\n let result = match parse_one_simple_selector(parser, input, *state)? {\n None => break,\n Some(result) => result,\n };\n\n if empty {\n if let Some(url) = parser.default_namespace() {\n // If there was no explicit type selector, but there is a\n // default namespace, there is an implicit \"|*\" type\n // selector. Except for :host() or :not() / :is() / :where(),\n // where we ignore it.\n //\n // https://drafts.csswg.org/css-scoping/#host-element-in-tree:\n //\n // When considered within its own shadow trees, the shadow\n // host is featureless. Only the :host, :host(), and\n // :host-context() pseudo-classes are allowed to match it.\n //\n // https://drafts.csswg.org/selectors-4/#featureless:\n //\n // A featureless element does not match any selector at all,\n // except those it is explicitly defined to match. If a\n // given selector is allowed to match a featureless element,\n // it must do so while ignoring the default namespace.\n //\n // https://drafts.csswg.org/selectors-4/#matches\n //\n // Default namespace declarations do not affect the compound\n // selector representing the subject of any selector within\n // a :is() pseudo-class, unless that compound selector\n // contains an explicit universal selector or type selector.\n //\n // (Similar quotes for :where() / :not())\n //\n let ignore_default_ns = state\n .intersects(SelectorParsingState::SKIP_DEFAULT_NAMESPACE)\n || matches!(\n result,\n SimpleSelectorParseResult::SimpleSelector(Component::Host(..))\n );\n if !ignore_default_ns {\n builder.push_simple_selector(Component::DefaultNamespace(url));\n }\n }\n }\n\n empty = false;\n\n match result {\n SimpleSelectorParseResult::SimpleSelector(s) => {\n builder.push_simple_selector(s);\n },\n SimpleSelectorParseResult::PartPseudo(part_names) => {\n state.insert(SelectorParsingState::AFTER_PART_LIKE);\n builder.push_combinator(Combinator::Part);\n builder.push_simple_selector(Component::Part(part_names));\n },\n SimpleSelectorParseResult::SlottedPseudo(selector) => {\n state.insert(SelectorParsingState::AFTER_SLOTTED);\n builder.push_combinator(Combinator::SlotAssignment);\n builder.push_simple_selector(Component::Slotted(selector));\n },\n SimpleSelectorParseResult::PseudoElement(p) => {\n if p.parses_as_element_backed() {\n state.insert(SelectorParsingState::AFTER_PART_LIKE);\n } else {\n state.insert(SelectorParsingState::AFTER_NON_ELEMENT_BACKED_PSEUDO);\n if p.is_before_or_after() {\n state.insert(SelectorParsingState::AFTER_BEFORE_OR_AFTER_PSEUDO);\n }\n }\n if !p.accepts_state_pseudo_classes() {\n state.insert(SelectorParsingState::AFTER_NON_STATEFUL_PSEUDO_ELEMENT);\n }\n if p.is_in_pseudo_element_tree() {\n state.insert(SelectorParsingState::IN_PSEUDO_ELEMENT_TREE);\n }\n builder.push_combinator(Combinator::PseudoElement);\n builder.push_simple_selector(Component::PseudoElement(p));\n },\n }\n }\n Ok(empty)\n}\n\nfn parse_is_where<'i, 't, P, Impl>(\n parser: &P,\n input: &mut CssParser<'i, 't>,\n state: SelectorParsingState,\n component: impl FnOnce(SelectorList) -> Component,\n) -> Result, ParseError<'i, P::Error>>\nwhere\n P: Parser<'i, Impl = Impl>,\n Impl: SelectorImpl,\n{\n debug_assert!(parser.parse_is_and_where());\n // https://drafts.csswg.org/selectors/#matches-pseudo:\n //\n // Pseudo-elements cannot be represented by the matches-any\n // pseudo-class; they are not valid within :is().\n //\n let inner = SelectorList::parse_with_state(\n parser,\n input,\n state\n | SelectorParsingState::SKIP_DEFAULT_NAMESPACE\n | SelectorParsingState::DISALLOW_PSEUDOS,\n ForgivingParsing::Yes,\n ParseRelative::No,\n )?;\n Ok(component(inner))\n}\n\nfn parse_has<'i, 't, P, Impl>(\n parser: &P,\n input: &mut CssParser<'i, 't>,\n state: SelectorParsingState,\n) -> Result, ParseError<'i, P::Error>>\nwhere\n P: Parser<'i, Impl = Impl>,\n Impl: SelectorImpl,\n{\n debug_assert!(parser.parse_has());\n if state.intersects(\n SelectorParsingState::DISALLOW_RELATIVE_SELECTOR | SelectorParsingState::AFTER_PSEUDO,\n ) {\n return Err(input.new_custom_error(SelectorParseErrorKind::InvalidState));\n }\n // Nested `:has()` is disallowed, mark it as such.\n // Note: The spec defines \":has-allowed pseudo-element,\" but there's no\n // pseudo-element defined as such at the moment.\n // https://w3c.github.io/csswg-drafts/selectors-4/#has-allowed-pseudo-element\n let inner = SelectorList::parse_with_state(\n parser,\n input,\n state\n | SelectorParsingState::SKIP_DEFAULT_NAMESPACE\n | SelectorParsingState::DISALLOW_PSEUDOS\n | SelectorParsingState::DISALLOW_RELATIVE_SELECTOR,\n ForgivingParsing::No,\n ParseRelative::ForHas,\n )?;\n Ok(Component::Has(RelativeSelector::from_selector_list(inner)))\n}\n\nfn parse_functional_pseudo_class<'i, 't, P, Impl>(\n parser: &P,\n input: &mut CssParser<'i, 't>,\n name: CowRcStr<'i>,\n state: SelectorParsingState,\n) -> Result, ParseError<'i, P::Error>>\nwhere\n P: Parser<'i, Impl = Impl>,\n Impl: SelectorImpl,\n{\n match_ignore_ascii_case! { &name,\n \"nth-child\" => return parse_nth_pseudo_class(parser, input, state, NthType::Child),\n \"nth-of-type\" => return parse_nth_pseudo_class(parser, input, state, NthType::OfType),\n \"nth-last-child\" => return parse_nth_pseudo_class(parser, input, state, NthType::LastChild),\n \"nth-last-of-type\" => return parse_nth_pseudo_class(parser, input, state, NthType::LastOfType),\n \"is\" if parser.parse_is_and_where() => return parse_is_where(parser, input, state, Component::Is),\n \"where\" if parser.parse_is_and_where() => return parse_is_where(parser, input, state, Component::Where),\n \"has\" if parser.parse_has() => return parse_has(parser, input, state),\n \"host\" => {\n if !state.allows_tree_structural_pseudo_classes() {\n return Err(input.new_custom_error(SelectorParseErrorKind::InvalidState));\n }\n return Ok(Component::Host(Some(parse_inner_compound_selector(parser, input, state)?)));\n },\n \"not\" => {\n return parse_negation(parser, input, state)\n },\n _ => {}\n }\n\n if parser.parse_is_and_where() && parser.is_is_alias(&name) {\n return parse_is_where(parser, input, state, Component::Is);\n }\n\n if state.intersects(\n SelectorParsingState::AFTER_NON_ELEMENT_BACKED_PSEUDO | SelectorParsingState::AFTER_SLOTTED,\n ) {\n return Err(input.new_custom_error(SelectorParseErrorKind::InvalidState));\n }\n\n let after_part = state.intersects(SelectorParsingState::AFTER_PART_LIKE);\n P::parse_non_ts_functional_pseudo_class(parser, name, input, after_part)\n .map(Component::NonTSPseudoClass)\n}\n\nfn parse_nth_pseudo_class<'i, 't, P, Impl>(\n parser: &P,\n input: &mut CssParser<'i, 't>,\n state: SelectorParsingState,\n ty: NthType,\n) -> Result, ParseError<'i, P::Error>>\nwhere\n P: Parser<'i, Impl = Impl>,\n Impl: SelectorImpl,\n{\n if !state.allows_tree_structural_pseudo_classes() {\n return Err(input.new_custom_error(SelectorParseErrorKind::InvalidState));\n }\n let (a, b) = parse_nth(input)?;\n let nth_data = NthSelectorData {\n ty,\n is_function: true,\n an_plus_b: AnPlusB(a, b),\n };\n if !parser.parse_nth_child_of() || ty.is_of_type() {\n return Ok(Component::Nth(nth_data));\n }\n\n // Try to parse \"of \".\n if input.try_parse(|i| i.expect_ident_matching(\"of\")).is_err() {\n return Ok(Component::Nth(nth_data));\n }\n // Whitespace between \"of\" and the selector list is optional\n // https://github.com/w3c/csswg-drafts/issues/8285\n let selectors = SelectorList::parse_with_state(\n parser,\n input,\n state\n | SelectorParsingState::SKIP_DEFAULT_NAMESPACE\n | SelectorParsingState::DISALLOW_PSEUDOS,\n ForgivingParsing::No,\n ParseRelative::No,\n )?;\n Ok(Component::NthOf(NthOfSelectorData::new(\n &nth_data,\n selectors.slice().iter().cloned(),\n )))\n}\n\n/// Returns whether the name corresponds to a CSS2 pseudo-element that\n/// can be specified with the single colon syntax (in addition to the\n/// double-colon syntax, which can be used for all pseudo-elements).\npub fn is_css2_pseudo_element(name: &str) -> bool {\n // ** Do not add to this list! **\n match_ignore_ascii_case! { name,\n \"before\" | \"after\" | \"first-line\" | \"first-letter\" => true,\n _ => false,\n }\n}\n\n/// Parse a simple selector other than a type selector.\n///\n/// * `Err(())`: Invalid selector, abort\n/// * `Ok(None)`: Not a simple selector, could be something else. `input` was not consumed.\n/// * `Ok(Some(_))`: Parsed a simple selector or pseudo-element\nfn parse_one_simple_selector<'i, 't, P, Impl>(\n parser: &P,\n input: &mut CssParser<'i, 't>,\n state: SelectorParsingState,\n) -> Result>, ParseError<'i, P::Error>>\nwhere\n P: Parser<'i, Impl = Impl>,\n Impl: SelectorImpl,\n{\n let start = input.state();\n let token = match input.next_including_whitespace().map(|t| t.clone()) {\n Ok(t) => t,\n Err(..) => {\n input.reset(&start);\n return Ok(None);\n },\n };\n\n Ok(Some(match token {\n Token::IDHash(id) => {\n if state.intersects(SelectorParsingState::AFTER_PSEUDO) {\n return Err(input.new_custom_error(SelectorParseErrorKind::InvalidState));\n }\n let id = Component::ID(id.as_ref().into());\n SimpleSelectorParseResult::SimpleSelector(id)\n },\n Token::Delim(delim) if delim == '.' || (delim == '&' && parser.parse_parent_selector()) => {\n if state.intersects(SelectorParsingState::AFTER_PSEUDO) {\n return Err(input.new_custom_error(SelectorParseErrorKind::InvalidState));\n }\n let location = input.current_source_location();\n SimpleSelectorParseResult::SimpleSelector(if delim == '&' {\n Component::ParentSelector\n } else {\n let class = match *input.next_including_whitespace()? {\n Token::Ident(ref class) => class,\n ref t => {\n let e = SelectorParseErrorKind::ClassNeedsIdent(t.clone());\n return Err(location.new_custom_error(e));\n },\n };\n Component::Class(class.as_ref().into())\n })\n },\n Token::SquareBracketBlock => {\n if state.intersects(SelectorParsingState::AFTER_PSEUDO) {\n return Err(input.new_custom_error(SelectorParseErrorKind::InvalidState));\n }\n let attr = input.parse_nested_block(|input| parse_attribute_selector(parser, input))?;\n SimpleSelectorParseResult::SimpleSelector(attr)\n },\n Token::Colon => {\n let location = input.current_source_location();\n let (is_single_colon, next_token) = match input.next_including_whitespace()?.clone() {\n Token::Colon => (false, input.next_including_whitespace()?.clone()),\n t => (true, t),\n };\n let (name, is_functional) = match next_token {\n Token::Ident(name) => (name, false),\n Token::Function(name) => (name, true),\n t => {\n let e = SelectorParseErrorKind::PseudoElementExpectedIdent(t);\n return Err(input.new_custom_error(e));\n },\n };\n let is_pseudo_element = !is_single_colon || is_css2_pseudo_element(&name);\n if is_pseudo_element {\n // Pseudos after pseudo elements are not allowed in some cases:\n // - Some states will disallow pseudos, such as the interiors of\n // :has/:is/:where/:not (DISALLOW_PSEUDOS).\n // - Non-element backed pseudos do not allow other pseudos to follow (AFTER_NON_ELEMENT_BACKED_PSEUDO)...\n // - ... except ::before and ::after, which allow _some_ pseudos.\n if state.intersects(SelectorParsingState::DISALLOW_PSEUDOS)\n || (state.intersects(SelectorParsingState::AFTER_NON_ELEMENT_BACKED_PSEUDO)\n && !state.intersects(SelectorParsingState::AFTER_BEFORE_OR_AFTER_PSEUDO))\n {\n return Err(input.new_custom_error(SelectorParseErrorKind::InvalidState));\n }\n let pseudo_element = if is_functional {\n if P::parse_part(parser) && name.eq_ignore_ascii_case(\"part\") {\n if !state.allows_part() {\n return Err(\n input.new_custom_error(SelectorParseErrorKind::InvalidState)\n );\n }\n let names = input.parse_nested_block(|input| {\n let mut result = Vec::with_capacity(1);\n result.push(input.expect_ident()?.as_ref().into());\n while !input.is_exhausted() {\n result.push(input.expect_ident()?.as_ref().into());\n }\n Ok(result.into_boxed_slice())\n })?;\n return Ok(Some(SimpleSelectorParseResult::PartPseudo(names)));\n }\n if P::parse_slotted(parser) && name.eq_ignore_ascii_case(\"slotted\") {\n if !state.allows_slotted() {\n return Err(\n input.new_custom_error(SelectorParseErrorKind::InvalidState)\n );\n }\n let selector = input.parse_nested_block(|input| {\n parse_inner_compound_selector(parser, input, state)\n })?;\n return Ok(Some(SimpleSelectorParseResult::SlottedPseudo(selector)));\n }\n input.parse_nested_block(|input| {\n P::parse_functional_pseudo_element(parser, name, input)\n })?\n } else {\n P::parse_pseudo_element(parser, location, name)?\n };\n\n if state.intersects(SelectorParsingState::AFTER_BEFORE_OR_AFTER_PSEUDO)\n && !pseudo_element.valid_after_before_or_after()\n {\n return Err(input.new_custom_error(SelectorParseErrorKind::InvalidState));\n }\n\n if state.intersects(SelectorParsingState::AFTER_SLOTTED)\n && !pseudo_element.valid_after_slotted()\n {\n return Err(input.new_custom_error(SelectorParseErrorKind::InvalidState));\n }\n SimpleSelectorParseResult::PseudoElement(pseudo_element)\n } else {\n let pseudo_class = if is_functional {\n input.parse_nested_block(|input| {\n parse_functional_pseudo_class(parser, input, name, state)\n })?\n } else {\n parse_simple_pseudo_class(parser, location, name, state)?\n };\n SimpleSelectorParseResult::SimpleSelector(pseudo_class)\n }\n },\n _ => {\n input.reset(&start);\n return Ok(None);\n },\n }))\n}\n\nfn parse_simple_pseudo_class<'i, P, Impl>(\n parser: &P,\n location: SourceLocation,\n name: CowRcStr<'i>,\n state: SelectorParsingState,\n) -> Result, ParseError<'i, P::Error>>\nwhere\n P: Parser<'i, Impl = Impl>,\n Impl: SelectorImpl,\n{\n if !state.allows_non_functional_pseudo_classes() {\n return Err(location.new_custom_error(SelectorParseErrorKind::InvalidState));\n }\n\n if state.allows_tree_structural_pseudo_classes() {\n // If a descendant pseudo of a pseudo-element root has no other siblings, then :only-child\n // matches that pseudo. Note that we don't accept other tree structural pseudo classes in\n // this case (to match other browsers). And the spec mentions only `:only-child` as well.\n // https://drafts.csswg.org/css-view-transitions-1/#pseudo-root\n if state.allows_only_child_pseudo_class_only() {\n if name.eq_ignore_ascii_case(\"only-child\") {\n return Ok(Component::Nth(NthSelectorData::only(\n /* of_type = */ false,\n )));\n }\n // Other non-functional pseudo classes are not allowed.\n // FIXME: Perhaps we can refactor this, e.g. distinguish tree-structural pseudo classes\n // from other non-ts pseudo classes. Otherwise, this special case looks weird.\n return Err(location.new_custom_error(SelectorParseErrorKind::InvalidState));\n }\n\n match_ignore_ascii_case! { &name,\n \"first-child\" => return Ok(Component::Nth(NthSelectorData::first(/* of_type = */ false))),\n \"last-child\" => return Ok(Component::Nth(NthSelectorData::last(/* of_type = */ false))),\n \"only-child\" => return Ok(Component::Nth(NthSelectorData::only(/* of_type = */ false))),\n \"root\" => return Ok(Component::Root),\n \"empty\" => return Ok(Component::Empty),\n \"scope\" => return Ok(Component::Scope),\n \"host\" if P::parse_host(parser) => return Ok(Component::Host(None)),\n \"first-of-type\" => return Ok(Component::Nth(NthSelectorData::first(/* of_type = */ true))),\n \"last-of-type\" => return Ok(Component::Nth(NthSelectorData::last(/* of_type = */ true))),\n \"only-of-type\" => return Ok(Component::Nth(NthSelectorData::only(/* of_type = */ true))),\n _ => {},\n }\n }\n\n let pseudo_class = P::parse_non_ts_pseudo_class(parser, location, name)?;\n if state.intersects(SelectorParsingState::AFTER_NON_ELEMENT_BACKED_PSEUDO)\n && !pseudo_class.is_user_action_state()\n {\n return Err(location.new_custom_error(SelectorParseErrorKind::InvalidState));\n }\n Ok(Component::NonTSPseudoClass(pseudo_class))\n}\n\n// NB: pub module in order to access the DummyParser\n#[cfg(test)]\npub mod tests {\n use super::*;\n use crate::builder::SelectorFlags;\n use crate::parser;\n use cssparser::{serialize_identifier, Parser as CssParser, ParserInput, ToCss};\n use std::collections::HashMap;\n use std::fmt;\n\n #[derive(Clone, Debug, Eq, PartialEq)]\n pub enum PseudoClass {\n Hover,\n Active,\n Lang(String),\n }\n\n #[derive(Clone, Debug, Eq, PartialEq)]\n pub enum PseudoElement {\n Before,\n After,\n Marker,\n DetailsContent,\n Highlight(String),\n }\n\n impl parser::PseudoElement for PseudoElement {\n type Impl = DummySelectorImpl;\n\n fn accepts_state_pseudo_classes(&self) -> bool {\n true\n }\n\n fn valid_after_slotted(&self) -> bool {\n true\n }\n\n fn valid_after_before_or_after(&self) -> bool {\n matches!(self, Self::Marker)\n }\n\n fn is_before_or_after(&self) -> bool {\n matches!(self, Self::Before | Self::After)\n }\n\n fn parses_as_element_backed(&self) -> bool {\n matches!(self, Self::DetailsContent)\n }\n }\n\n impl parser::NonTSPseudoClass for PseudoClass {\n type Impl = DummySelectorImpl;\n\n #[inline]\n fn is_active_or_hover(&self) -> bool {\n matches!(*self, PseudoClass::Active | PseudoClass::Hover)\n }\n\n #[inline]\n fn is_user_action_state(&self) -> bool {\n self.is_active_or_hover()\n }\n }\n\n impl ToCss for PseudoClass {\n fn to_css(&self, dest: &mut W) -> fmt::Result\n where\n W: fmt::Write,\n {\n match *self {\n PseudoClass::Hover => dest.write_str(\":hover\"),\n PseudoClass::Active => dest.write_str(\":active\"),\n PseudoClass::Lang(ref lang) => {\n dest.write_str(\":lang(\")?;\n serialize_identifier(lang, dest)?;\n dest.write_char(')')\n },\n }\n }\n }\n\n impl ToCss for PseudoElement {\n fn to_css(&self, dest: &mut W) -> fmt::Result\n where\n W: fmt::Write,\n {\n match *self {\n PseudoElement::Before => dest.write_str(\"::before\"),\n PseudoElement::After => dest.write_str(\"::after\"),\n PseudoElement::Marker => dest.write_str(\"::marker\"),\n PseudoElement::DetailsContent => dest.write_str(\"::details-content\"),\n PseudoElement::Highlight(ref name) => {\n dest.write_str(\"::highlight(\")?;\n serialize_identifier(&name, dest)?;\n dest.write_char(')')\n },\n }\n }\n }\n\n #[derive(Clone, Debug, PartialEq)]\n pub struct DummySelectorImpl;\n\n #[derive(Default)]\n pub struct DummyParser {\n default_ns: Option,\n ns_prefixes: HashMap,\n }\n\n impl DummyParser {\n fn default_with_namespace(default_ns: DummyAtom) -> DummyParser {\n DummyParser {\n default_ns: Some(default_ns),\n ns_prefixes: Default::default(),\n }\n }\n }\n\n impl SelectorImpl for DummySelectorImpl {\n type ExtraMatchingData<'a> = std::marker::PhantomData<&'a ()>;\n type AttrValue = DummyAttrValue;\n type Identifier = DummyAtom;\n type LocalName = DummyAtom;\n type NamespaceUrl = DummyAtom;\n type NamespacePrefix = DummyAtom;\n type BorrowedLocalName = DummyAtom;\n type BorrowedNamespaceUrl = DummyAtom;\n type NonTSPseudoClass = PseudoClass;\n type PseudoElement = PseudoElement;\n }\n\n #[derive(Clone, Debug, Default, Eq, Hash, PartialEq)]\n pub struct DummyAttrValue(String);\n\n impl ToCss for DummyAttrValue {\n fn to_css(&self, dest: &mut W) -> fmt::Result\n where\n W: fmt::Write,\n {\n use std::fmt::Write;\n\n dest.write_char('\"')?;\n write!(cssparser::CssStringWriter::new(dest), \"{}\", &self.0)?;\n dest.write_char('\"')\n }\n }\n\n impl<'a> From<&'a str> for DummyAttrValue {\n fn from(string: &'a str) -> Self {\n Self(string.into())\n }\n }\n\n #[derive(Clone, Debug, Default, Eq, Hash, PartialEq)]\n pub struct DummyAtom(String);\n\n impl ToCss for DummyAtom {\n fn to_css(&self, dest: &mut W) -> fmt::Result\n where\n W: fmt::Write,\n {\n serialize_identifier(&self.0, dest)\n }\n }\n\n impl From for DummyAtom {\n fn from(string: String) -> Self {\n DummyAtom(string)\n }\n }\n\n impl<'a> From<&'a str> for DummyAtom {\n fn from(string: &'a str) -> Self {\n DummyAtom(string.into())\n }\n }\n\n impl PrecomputedHash for DummyAtom {\n fn precomputed_hash(&self) -> u32 {\n self.0.as_ptr() as u32\n }\n }\n\n impl<'i> Parser<'i> for DummyParser {\n type Impl = DummySelectorImpl;\n type Error = SelectorParseErrorKind<'i>;\n\n fn parse_slotted(&self) -> bool {\n true\n }\n\n fn parse_nth_child_of(&self) -> bool {\n true\n }\n\n fn parse_is_and_where(&self) -> bool {\n true\n }\n\n fn parse_has(&self) -> bool {\n true\n }\n\n fn parse_parent_selector(&self) -> bool {\n true\n }\n\n fn parse_part(&self) -> bool {\n true\n }\n\n fn parse_host(&self) -> bool {\n true\n }\n\n fn parse_non_ts_pseudo_class(\n &self,\n location: SourceLocation,\n name: CowRcStr<'i>,\n ) -> Result> {\n match_ignore_ascii_case! { &name,\n \"hover\" => return Ok(PseudoClass::Hover),\n \"active\" => return Ok(PseudoClass::Active),\n _ => {}\n }\n Err(\n location.new_custom_error(SelectorParseErrorKind::UnsupportedPseudoClassOrElement(\n name,\n )),\n )\n }\n\n fn parse_non_ts_functional_pseudo_class<'t>(\n &self,\n name: CowRcStr<'i>,\n parser: &mut CssParser<'i, 't>,\n after_part: bool,\n ) -> Result> {\n match_ignore_ascii_case! { &name,\n \"lang\" if !after_part => {\n let lang = parser.expect_ident_or_string()?.as_ref().to_owned();\n return Ok(PseudoClass::Lang(lang));\n },\n _ => {}\n }\n Err(\n parser.new_custom_error(SelectorParseErrorKind::UnsupportedPseudoClassOrElement(\n name,\n )),\n )\n }\n\n fn parse_pseudo_element(\n &self,\n location: SourceLocation,\n name: CowRcStr<'i>,\n ) -> Result> {\n match_ignore_ascii_case! { &name,\n \"before\" => return Ok(PseudoElement::Before),\n \"after\" => return Ok(PseudoElement::After),\n \"marker\" => return Ok(PseudoElement::Marker),\n \"details-content\" => return Ok(PseudoElement::DetailsContent),\n _ => {}\n }\n Err(\n location.new_custom_error(SelectorParseErrorKind::UnsupportedPseudoClassOrElement(\n name,\n )),\n )\n }\n\n fn parse_functional_pseudo_element<'t>(\n &self,\n name: CowRcStr<'i>,\n parser: &mut CssParser<'i, 't>,\n ) -> Result> {\n match_ignore_ascii_case! { &name,\n \"highlight\" => return Ok(PseudoElement::Highlight(parser.expect_ident()?.as_ref().to_owned())),\n _ => {}\n }\n Err(\n parser.new_custom_error(SelectorParseErrorKind::UnsupportedPseudoClassOrElement(\n name,\n )),\n )\n }\n\n fn default_namespace(&self) -> Option {\n self.default_ns.clone()\n }\n\n fn namespace_for_prefix(&self, prefix: &DummyAtom) -> Option {\n self.ns_prefixes.get(prefix).cloned()\n }\n }\n\n fn parse<'i>(\n input: &'i str,\n ) -> Result, SelectorParseError<'i>> {\n parse_relative(input, ParseRelative::No)\n }\n\n fn parse_relative<'i>(\n input: &'i str,\n parse_relative: ParseRelative,\n ) -> Result, SelectorParseError<'i>> {\n parse_ns_relative(input, &DummyParser::default(), parse_relative)\n }\n\n fn parse_expected<'i, 'a>(\n input: &'i str,\n expected: Option<&'a str>,\n ) -> Result, SelectorParseError<'i>> {\n parse_ns_expected(input, &DummyParser::default(), expected)\n }\n\n fn parse_relative_expected<'i, 'a>(\n input: &'i str,\n parse_relative: ParseRelative,\n expected: Option<&'a str>,\n ) -> Result, SelectorParseError<'i>> {\n parse_ns_relative_expected(input, &DummyParser::default(), parse_relative, expected)\n }\n\n fn parse_ns<'i>(\n input: &'i str,\n parser: &DummyParser,\n ) -> Result, SelectorParseError<'i>> {\n parse_ns_relative(input, parser, ParseRelative::No)\n }\n\n fn parse_ns_relative<'i>(\n input: &'i str,\n parser: &DummyParser,\n parse_relative: ParseRelative,\n ) -> Result, SelectorParseError<'i>> {\n parse_ns_relative_expected(input, parser, parse_relative, None)\n }\n\n fn parse_ns_expected<'i, 'a>(\n input: &'i str,\n parser: &DummyParser,\n expected: Option<&'a str>,\n ) -> Result, SelectorParseError<'i>> {\n parse_ns_relative_expected(input, parser, ParseRelative::No, expected)\n }\n\n fn parse_ns_relative_expected<'i, 'a>(\n input: &'i str,\n parser: &DummyParser,\n parse_relative: ParseRelative,\n expected: Option<&'a str>,\n ) -> Result, SelectorParseError<'i>> {\n let mut parser_input = ParserInput::new(input);\n let result = SelectorList::parse(\n parser,\n &mut CssParser::new(&mut parser_input),\n parse_relative,\n );\n if let Ok(ref selectors) = result {\n // We can't assume that the serialized parsed selector will equal\n // the input; for example, if there is no default namespace, '*|foo'\n // should serialize to 'foo'.\n assert_eq!(\n selectors.to_css_string(),\n match expected {\n Some(x) => x,\n None => input,\n }\n );\n }\n result\n }\n\n fn specificity(a: u32, b: u32, c: u32) -> u32 {\n a << 20 | b << 10 | c\n }\n\n #[test]\n fn test_empty() {\n let mut input = ParserInput::new(\":empty\");\n let list = SelectorList::parse(\n &DummyParser::default(),\n &mut CssParser::new(&mut input),\n ParseRelative::No,\n );\n assert!(list.is_ok());\n }\n\n const MATHML: &str = \"http://www.w3.org/1998/Math/MathML\";\n const SVG: &str = \"http://www.w3.org/2000/svg\";\n\n #[test]\n fn test_parsing() {\n assert!(parse(\"\").is_err());\n assert!(parse(\":lang(4)\").is_err());\n assert!(parse(\":lang(en US)\").is_err());\n assert_eq!(\n parse(\"EeÉ\"),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![Component::LocalName(LocalName {\n name: DummyAtom::from(\"EeÉ\"),\n lower_name: DummyAtom::from(\"eeÉ\"),\n })],\n specificity(0, 0, 1),\n SelectorFlags::empty(),\n )]))\n );\n assert_eq!(\n parse(\"|e\"),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![\n Component::ExplicitNoNamespace,\n Component::LocalName(LocalName {\n name: DummyAtom::from(\"e\"),\n lower_name: DummyAtom::from(\"e\"),\n }),\n ],\n specificity(0, 0, 1),\n SelectorFlags::empty(),\n )]))\n );\n // When the default namespace is not set, *| should be elided.\n // https://github.com/servo/servo/pull/17537\n assert_eq!(\n parse_expected(\"*|e\", Some(\"e\")),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![Component::LocalName(LocalName {\n name: DummyAtom::from(\"e\"),\n lower_name: DummyAtom::from(\"e\"),\n })],\n specificity(0, 0, 1),\n SelectorFlags::empty(),\n )]))\n );\n // When the default namespace is set, *| should _not_ be elided (as foo\n // is no longer equivalent to *|foo--the former is only for foo in the\n // default namespace).\n // https://github.com/servo/servo/issues/16020\n assert_eq!(\n parse_ns(\n \"*|e\",\n &DummyParser::default_with_namespace(DummyAtom::from(\"https://mozilla.org\"))\n ),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![\n Component::ExplicitAnyNamespace,\n Component::LocalName(LocalName {\n name: DummyAtom::from(\"e\"),\n lower_name: DummyAtom::from(\"e\"),\n }),\n ],\n specificity(0, 0, 1),\n SelectorFlags::empty(),\n )]))\n );\n assert_eq!(\n parse(\"*\"),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![Component::ExplicitUniversalType],\n specificity(0, 0, 0),\n SelectorFlags::empty(),\n )]))\n );\n assert_eq!(\n parse(\"|*\"),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![\n Component::ExplicitNoNamespace,\n Component::ExplicitUniversalType,\n ],\n specificity(0, 0, 0),\n SelectorFlags::empty(),\n )]))\n );\n assert_eq!(\n parse_expected(\"*|*\", Some(\"*\")),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![Component::ExplicitUniversalType],\n specificity(0, 0, 0),\n SelectorFlags::empty(),\n )]))\n );\n assert_eq!(\n parse_ns(\n \"*|*\",\n &DummyParser::default_with_namespace(DummyAtom::from(\"https://mozilla.org\"))\n ),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![\n Component::ExplicitAnyNamespace,\n Component::ExplicitUniversalType,\n ],\n specificity(0, 0, 0),\n SelectorFlags::empty(),\n )]))\n );\n assert_eq!(\n parse(\".foo:lang(en-US)\"),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![\n Component::Class(DummyAtom::from(\"foo\")),\n Component::NonTSPseudoClass(PseudoClass::Lang(\"en-US\".to_owned())),\n ],\n specificity(0, 2, 0),\n SelectorFlags::empty(),\n )]))\n );\n assert_eq!(\n parse(\"#bar\"),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![Component::ID(DummyAtom::from(\"bar\"))],\n specificity(1, 0, 0),\n SelectorFlags::empty(),\n )]))\n );\n assert_eq!(\n parse(\"e.foo#bar\"),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![\n Component::LocalName(LocalName {\n name: DummyAtom::from(\"e\"),\n lower_name: DummyAtom::from(\"e\"),\n }),\n Component::Class(DummyAtom::from(\"foo\")),\n Component::ID(DummyAtom::from(\"bar\")),\n ],\n specificity(1, 1, 1),\n SelectorFlags::empty(),\n )]))\n );\n assert_eq!(\n parse(\"e.foo #bar\"),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![\n Component::LocalName(LocalName {\n name: DummyAtom::from(\"e\"),\n lower_name: DummyAtom::from(\"e\"),\n }),\n Component::Class(DummyAtom::from(\"foo\")),\n Component::Combinator(Combinator::Descendant),\n Component::ID(DummyAtom::from(\"bar\")),\n ],\n specificity(1, 1, 1),\n SelectorFlags::empty(),\n )]))\n );\n // Default namespace does not apply to attribute selectors\n // https://github.com/mozilla/servo/pull/1652\n let mut parser = DummyParser::default();\n assert_eq!(\n parse_ns(\"[Foo]\", &parser),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![Component::AttributeInNoNamespaceExists {\n local_name: DummyAtom::from(\"Foo\"),\n local_name_lower: DummyAtom::from(\"foo\"),\n }],\n specificity(0, 1, 0),\n SelectorFlags::empty(),\n )]))\n );\n assert!(parse_ns(\"svg|circle\", &parser).is_err());\n parser\n .ns_prefixes\n .insert(DummyAtom(\"svg\".into()), DummyAtom(SVG.into()));\n assert_eq!(\n parse_ns(\"svg|circle\", &parser),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![\n Component::Namespace(DummyAtom(\"svg\".into()), SVG.into()),\n Component::LocalName(LocalName {\n name: DummyAtom::from(\"circle\"),\n lower_name: DummyAtom::from(\"circle\"),\n }),\n ],\n specificity(0, 0, 1),\n SelectorFlags::empty(),\n )]))\n );\n assert_eq!(\n parse_ns(\"svg|*\", &parser),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![\n Component::Namespace(DummyAtom(\"svg\".into()), SVG.into()),\n Component::ExplicitUniversalType,\n ],\n specificity(0, 0, 0),\n SelectorFlags::empty(),\n )]))\n );\n // Default namespace does not apply to attribute selectors\n // https://github.com/mozilla/servo/pull/1652\n // but it does apply to implicit type selectors\n // https://github.com/servo/rust-selectors/pull/82\n parser.default_ns = Some(MATHML.into());\n assert_eq!(\n parse_ns(\"[Foo]\", &parser),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![\n Component::DefaultNamespace(MATHML.into()),\n Component::AttributeInNoNamespaceExists {\n local_name: DummyAtom::from(\"Foo\"),\n local_name_lower: DummyAtom::from(\"foo\"),\n },\n ],\n specificity(0, 1, 0),\n SelectorFlags::empty(),\n )]))\n );\n // Default namespace does apply to type selectors\n assert_eq!(\n parse_ns(\"e\", &parser),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![\n Component::DefaultNamespace(MATHML.into()),\n Component::LocalName(LocalName {\n name: DummyAtom::from(\"e\"),\n lower_name: DummyAtom::from(\"e\"),\n }),\n ],\n specificity(0, 0, 1),\n SelectorFlags::empty(),\n )]))\n );\n assert_eq!(\n parse_ns(\"*\", &parser),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![\n Component::DefaultNamespace(MATHML.into()),\n Component::ExplicitUniversalType,\n ],\n specificity(0, 0, 0),\n SelectorFlags::empty(),\n )]))\n );\n assert_eq!(\n parse_ns(\"*|*\", &parser),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![\n Component::ExplicitAnyNamespace,\n Component::ExplicitUniversalType,\n ],\n specificity(0, 0, 0),\n SelectorFlags::empty(),\n )]))\n );\n // Default namespace applies to universal and type selectors inside :not and :matches,\n // but not otherwise.\n assert_eq!(\n parse_ns(\":not(.cl)\", &parser),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![\n Component::DefaultNamespace(MATHML.into()),\n Component::Negation(SelectorList::from_vec(vec![Selector::from_vec(\n vec![Component::Class(DummyAtom::from(\"cl\"))],\n specificity(0, 1, 0),\n SelectorFlags::empty(),\n )])),\n ],\n specificity(0, 1, 0),\n SelectorFlags::empty(),\n )]))\n );\n assert_eq!(\n parse_ns(\":not(*)\", &parser),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![\n Component::DefaultNamespace(MATHML.into()),\n Component::Negation(SelectorList::from_vec(vec![Selector::from_vec(\n vec![\n Component::DefaultNamespace(MATHML.into()),\n Component::ExplicitUniversalType,\n ],\n specificity(0, 0, 0),\n SelectorFlags::empty(),\n )]),),\n ],\n specificity(0, 0, 0),\n SelectorFlags::empty(),\n )]))\n );\n assert_eq!(\n parse_ns(\":not(e)\", &parser),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![\n Component::DefaultNamespace(MATHML.into()),\n Component::Negation(SelectorList::from_vec(vec![Selector::from_vec(\n vec![\n Component::DefaultNamespace(MATHML.into()),\n Component::LocalName(LocalName {\n name: DummyAtom::from(\"e\"),\n lower_name: DummyAtom::from(\"e\"),\n }),\n ],\n specificity(0, 0, 1),\n SelectorFlags::empty(),\n )])),\n ],\n specificity(0, 0, 1),\n SelectorFlags::empty(),\n )]))\n );\n assert_eq!(\n parse(\"[attr|=\\\"foo\\\"]\"),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![Component::AttributeInNoNamespace {\n local_name: DummyAtom::from(\"attr\"),\n operator: AttrSelectorOperator::DashMatch,\n value: DummyAttrValue::from(\"foo\"),\n case_sensitivity: ParsedCaseSensitivity::CaseSensitive,\n }],\n specificity(0, 1, 0),\n SelectorFlags::empty(),\n )]))\n );\n // https://github.com/mozilla/servo/issues/1723\n assert_eq!(\n parse(\"::before\"),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![\n Component::Combinator(Combinator::PseudoElement),\n Component::PseudoElement(PseudoElement::Before),\n ],\n specificity(0, 0, 1),\n SelectorFlags::HAS_PSEUDO,\n )]))\n );\n assert_eq!(\n parse(\"::before:hover\"),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![\n Component::Combinator(Combinator::PseudoElement),\n Component::PseudoElement(PseudoElement::Before),\n Component::NonTSPseudoClass(PseudoClass::Hover),\n ],\n specificity(0, 1, 1),\n SelectorFlags::HAS_PSEUDO,\n )]))\n );\n assert_eq!(\n parse(\"::before:hover:hover\"),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![\n Component::Combinator(Combinator::PseudoElement),\n Component::PseudoElement(PseudoElement::Before),\n Component::NonTSPseudoClass(PseudoClass::Hover),\n Component::NonTSPseudoClass(PseudoClass::Hover),\n ],\n specificity(0, 2, 1),\n SelectorFlags::HAS_PSEUDO,\n )]))\n );\n assert!(parse(\"::before:hover:lang(foo)\").is_err());\n assert!(parse(\"::before:hover .foo\").is_err());\n assert!(parse(\"::before .foo\").is_err());\n assert!(parse(\"::before ~ bar\").is_err());\n assert!(parse(\"::before:active\").is_ok());\n\n // https://github.com/servo/servo/issues/15335\n assert!(parse(\":: before\").is_err());\n assert_eq!(\n parse(\"div ::after\"),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![\n Component::LocalName(LocalName {\n name: DummyAtom::from(\"div\"),\n lower_name: DummyAtom::from(\"div\"),\n }),\n Component::Combinator(Combinator::Descendant),\n Component::Combinator(Combinator::PseudoElement),\n Component::PseudoElement(PseudoElement::After),\n ],\n specificity(0, 0, 2),\n SelectorFlags::HAS_PSEUDO,\n )]))\n );\n assert_eq!(\n parse(\"#d1 > .ok\"),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![\n Component::ID(DummyAtom::from(\"d1\")),\n Component::Combinator(Combinator::Child),\n Component::Class(DummyAtom::from(\"ok\")),\n ],\n specificity(1, 1, 0),\n SelectorFlags::empty(),\n )]))\n );\n parser.default_ns = None;\n assert!(parse(\":not(#provel.old)\").is_ok());\n assert!(parse(\":not(#provel > old)\").is_ok());\n assert!(parse(\"table[rules]:not([rules=\\\"none\\\"]):not([rules=\\\"\\\"])\").is_ok());\n // https://github.com/servo/servo/issues/16017\n assert_eq!(\n parse_ns(\":not(*)\", &parser),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![Component::Negation(SelectorList::from_vec(vec![\n Selector::from_vec(\n vec![Component::ExplicitUniversalType],\n specificity(0, 0, 0),\n SelectorFlags::empty(),\n )\n ]))],\n specificity(0, 0, 0),\n SelectorFlags::empty(),\n )]))\n );\n assert_eq!(\n parse_ns(\":not(|*)\", &parser),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![Component::Negation(SelectorList::from_vec(vec![\n Selector::from_vec(\n vec![\n Component::ExplicitNoNamespace,\n Component::ExplicitUniversalType,\n ],\n specificity(0, 0, 0),\n SelectorFlags::empty(),\n )\n ]))],\n specificity(0, 0, 0),\n SelectorFlags::empty(),\n )]))\n );\n // *| should be elided if there is no default namespace.\n // https://github.com/servo/servo/pull/17537\n assert_eq!(\n parse_ns_expected(\":not(*|*)\", &parser, Some(\":not(*)\")),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![Component::Negation(SelectorList::from_vec(vec![\n Selector::from_vec(\n vec![Component::ExplicitUniversalType],\n specificity(0, 0, 0),\n SelectorFlags::empty(),\n )\n ]))],\n specificity(0, 0, 0),\n SelectorFlags::empty(),\n )]))\n );\n\n assert!(parse(\"::highlight(foo)\").is_ok());\n\n assert!(parse(\"::slotted()\").is_err());\n assert!(parse(\"::slotted(div)\").is_ok());\n assert!(parse(\"::slotted(div).foo\").is_err());\n assert!(parse(\"::slotted(div + bar)\").is_err());\n assert!(parse(\"::slotted(div) + foo\").is_err());\n\n assert!(parse(\"::part()\").is_err());\n assert!(parse(\"::part(42)\").is_err());\n assert!(parse(\"::part(foo bar)\").is_ok());\n assert!(parse(\"::part(foo):hover\").is_ok());\n assert!(parse(\"::part(foo) + bar\").is_err());\n\n assert!(parse(\"div ::slotted(div)\").is_ok());\n assert!(parse(\"div + slot::slotted(div)\").is_ok());\n assert!(parse(\"div + slot::slotted(div.foo)\").is_ok());\n assert!(parse(\"slot::slotted(div,foo)::first-line\").is_err());\n assert!(parse(\"::slotted(div)::before\").is_ok());\n assert!(parse(\"slot::slotted(div,foo)\").is_err());\n\n assert!(parse(\"foo:where()\").is_ok());\n assert!(parse(\"foo:where(div, foo, .bar baz)\").is_ok());\n assert!(parse(\"foo:where(::before)\").is_ok());\n }\n\n #[test]\n fn parent_selector() {\n assert!(parse(\"foo &\").is_ok());\n assert_eq!(\n parse(\"#foo &.bar\"),\n Ok(SelectorList::from_vec(vec![Selector::from_vec(\n vec![\n Component::ID(DummyAtom::from(\"foo\")),\n Component::Combinator(Combinator::Descendant),\n Component::ParentSelector,\n Component::Class(DummyAtom::from(\"bar\")),\n ],\n specificity(1, 1, 0),\n SelectorFlags::HAS_PARENT\n )]))\n );\n\n let parent = parse(\".bar, div .baz\").unwrap();\n let child = parse(\"#foo &.bar\").unwrap();\n assert_eq!(\n child.replace_parent_selector(&parent),\n parse(\"#foo :is(.bar, div .baz).bar\").unwrap()\n );\n\n let has_child = parse(\"#foo:has(&.bar)\").unwrap();\n assert_eq!(\n has_child.replace_parent_selector(&parent),\n parse(\"#foo:has(:is(.bar, div .baz).bar)\").unwrap()\n );\n\n let child =\n parse_relative_expected(\"#foo\", ParseRelative::ForNesting, Some(\"& #foo\")).unwrap();\n assert_eq!(\n child.replace_parent_selector(&parent),\n parse(\":is(.bar, div .baz) #foo\").unwrap()\n );\n\n let child =\n parse_relative_expected(\"+ #foo\", ParseRelative::ForNesting, Some(\"& + #foo\")).unwrap();\n assert_eq!(child, parse(\"& + #foo\").unwrap());\n }\n\n #[test]\n fn test_pseudo_iter() {\n let list = parse(\"q::before\").unwrap();\n let selector = &list.slice()[0];\n assert!(!selector.is_universal());\n let mut iter = selector.iter();\n assert_eq!(\n iter.next(),\n Some(&Component::PseudoElement(PseudoElement::Before))\n );\n assert_eq!(iter.next(), None);\n let combinator = iter.next_sequence();\n assert_eq!(combinator, Some(Combinator::PseudoElement));\n assert_eq!(\n iter.next(),\n Some(&Component::LocalName(LocalName {\n name: DummyAtom::from(\"q\"),\n lower_name: DummyAtom::from(\"q\"),\n }))\n );\n assert_eq!(iter.next(), None);\n assert_eq!(iter.next_sequence(), None);\n }\n\n #[test]\n fn test_pseudo_before_marker() {\n let list = parse(\"::before::marker\").unwrap();\n let selector = &list.slice()[0];\n let mut iter = selector.iter();\n assert_eq!(\n iter.next(),\n Some(&Component::PseudoElement(PseudoElement::Marker))\n );\n assert_eq!(iter.next(), None);\n let combinator = iter.next_sequence();\n assert_eq!(combinator, Some(Combinator::PseudoElement));\n assert_eq!(\n iter.next(),\n Some(&Component::PseudoElement(PseudoElement::Before))\n );\n assert_eq!(iter.next(), None);\n let combinator = iter.next_sequence();\n assert_eq!(combinator, Some(Combinator::PseudoElement));\n assert_eq!(iter.next(), None);\n assert_eq!(iter.next_sequence(), None);\n }\n\n #[test]\n fn test_pseudo_duplicate_before_after_or_marker() {\n assert!(parse(\"::before::before\").is_err());\n assert!(parse(\"::after::after\").is_err());\n assert!(parse(\"::marker::marker\").is_err());\n }\n\n #[test]\n fn test_pseudo_on_element_backed_pseudo() {\n let list = parse(\"::details-content::before\").unwrap();\n let selector = &list.slice()[0];\n let mut iter = selector.iter();\n assert_eq!(\n iter.next(),\n Some(&Component::PseudoElement(PseudoElement::Before))\n );\n assert_eq!(iter.next(), None);\n let combinator = iter.next_sequence();\n assert_eq!(combinator, Some(Combinator::PseudoElement));\n assert_eq!(\n iter.next(),\n Some(&Component::PseudoElement(PseudoElement::DetailsContent))\n );\n assert_eq!(iter.next(), None);\n let combinator = iter.next_sequence();\n assert_eq!(combinator, Some(Combinator::PseudoElement));\n assert_eq!(iter.next(), None);\n assert_eq!(iter.next_sequence(), None);\n }\n\n #[test]\n fn test_universal() {\n let list = parse_ns(\n \"*|*::before\",\n &DummyParser::default_with_namespace(DummyAtom::from(\"https://mozilla.org\")),\n )\n .unwrap();\n let selector = &list.slice()[0];\n assert!(selector.is_universal());\n }\n\n #[test]\n fn test_empty_pseudo_iter() {\n let list = parse(\"::before\").unwrap();\n let selector = &list.slice()[0];\n assert!(selector.is_universal());\n let mut iter = selector.iter();\n assert_eq!(\n iter.next(),\n Some(&Component::PseudoElement(PseudoElement::Before))\n );\n assert_eq!(iter.next(), None);\n assert_eq!(iter.next_sequence(), Some(Combinator::PseudoElement));\n assert_eq!(iter.next(), None);\n assert_eq!(iter.next_sequence(), None);\n }\n\n #[test]\n fn test_parse_implicit_scope() {\n assert_eq!(\n parse_relative_expected(\".foo\", ParseRelative::ForScope, None).unwrap(),\n SelectorList::from_vec(vec![Selector::from_vec(\n vec![\n Component::ImplicitScope,\n Component::Combinator(Combinator::Descendant),\n Component::Class(DummyAtom::from(\"foo\")),\n ],\n specificity(0, 1, 0),\n SelectorFlags::HAS_SCOPE,\n )])\n );\n\n assert_eq!(\n parse_relative_expected(\":scope .foo\", ParseRelative::ForScope, None).unwrap(),\n SelectorList::from_vec(vec![Selector::from_vec(\n vec![\n Component::Scope,\n Component::Combinator(Combinator::Descendant),\n Component::Class(DummyAtom::from(\"foo\")),\n ],\n specificity(0, 2, 0),\n SelectorFlags::HAS_SCOPE\n )])\n );\n\n assert_eq!(\n parse_relative_expected(\"> .foo\", ParseRelative::ForScope, Some(\"> .foo\")).unwrap(),\n SelectorList::from_vec(vec![Selector::from_vec(\n vec![\n Component::ImplicitScope,\n Component::Combinator(Combinator::Child),\n Component::Class(DummyAtom::from(\"foo\")),\n ],\n specificity(0, 1, 0),\n SelectorFlags::HAS_SCOPE\n )])\n );\n\n assert_eq!(\n parse_relative_expected(\".foo :scope > .bar\", ParseRelative::ForScope, None).unwrap(),\n SelectorList::from_vec(vec![Selector::from_vec(\n vec![\n Component::Class(DummyAtom::from(\"foo\")),\n Component::Combinator(Combinator::Descendant),\n Component::Scope,\n Component::Combinator(Combinator::Child),\n Component::Class(DummyAtom::from(\"bar\")),\n ],\n specificity(0, 3, 0),\n SelectorFlags::HAS_SCOPE\n )])\n );\n }\n\n struct TestVisitor {\n seen: Vec,\n }\n\n impl SelectorVisitor for TestVisitor {\n type Impl = DummySelectorImpl;\n\n fn visit_simple_selector(&mut self, s: &Component) -> bool {\n let mut dest = String::new();\n s.to_css(&mut dest).unwrap();\n self.seen.push(dest);\n true\n }\n }\n\n #[test]\n fn visitor() {\n let mut test_visitor = TestVisitor { seen: vec![] };\n parse(\":not(:hover) ~ label\").unwrap().slice()[0].visit(&mut test_visitor);\n assert!(test_visitor.seen.contains(&\":hover\".into()));\n\n let mut test_visitor = TestVisitor { seen: vec![] };\n parse(\"::before:hover\").unwrap().slice()[0].visit(&mut test_visitor);\n assert!(test_visitor.seen.contains(&\":hover\".into()));\n }\n}\n" }, { "path": "selectors/relative_selector/cache.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\nuse rustc_hash::FxHashMap;\n/// Relative selector cache. This is useful for following cases.\n/// First case is non-subject relative selector: Imagine `.anchor:has(<..>) ~ .foo`, with DOM\n/// `.anchor + .foo + .. + .foo`. Each match on `.foo` triggers `:has()` traversal that\n/// yields the same result. This is simple enough, since we just need to store\n/// the exact match on that anchor pass/fail.\n/// Second case is `querySelectorAll`: Imagine `querySelectorAll(':has(.a)')`, with DOM\n/// `div > .. > div > .a`. When the we perform the traversal at the top div,\n/// we basically end up evaluating `:has(.a)` for all anchors, which could be reused.\n/// Also consider the sibling version: `querySelectorAll(':has(~ .a)')` with DOM\n/// `div + .. + div + .a`.\n/// TODO(dshin): Second case is not yet handled. That is tracked in Bug 1845291.\nuse std::hash::Hash;\n\nuse crate::parser::{RelativeSelector, SelectorKey};\nuse crate::{tree::OpaqueElement, SelectorImpl};\n\n/// Match data for a given element and a selector.\n#[derive(Clone, Copy)]\npub enum RelativeSelectorCachedMatch {\n /// This selector matches this element.\n Matched,\n /// This selector does not match this element.\n NotMatched,\n}\n\nimpl RelativeSelectorCachedMatch {\n /// Is the cached result a match?\n pub fn matched(&self) -> bool {\n matches!(*self, Self::Matched)\n }\n}\n\n#[derive(Clone, Copy, Hash, Eq, PartialEq)]\nstruct Key {\n element: OpaqueElement,\n selector: SelectorKey,\n}\n\nimpl Key {\n pub fn new(\n element: OpaqueElement,\n selector: &RelativeSelector,\n ) -> Self {\n Key {\n element,\n selector: SelectorKey::new(&selector.selector),\n }\n }\n}\n\n/// Cache to speed up matching of relative selectors.\n#[derive(Default)]\npub struct RelativeSelectorCache {\n cache: FxHashMap,\n}\n\nimpl RelativeSelectorCache {\n /// Add a relative selector match into the cache.\n pub fn add(\n &mut self,\n anchor: OpaqueElement,\n selector: &RelativeSelector,\n matched: RelativeSelectorCachedMatch,\n ) {\n self.cache.insert(Key::new(anchor, selector), matched);\n }\n\n /// Check if we have a cache entry for the element.\n pub fn lookup(\n &mut self,\n element: OpaqueElement,\n selector: &RelativeSelector,\n ) -> Option {\n self.cache.get(&Key::new(element, selector)).copied()\n }\n}\n" }, { "path": "selectors/relative_selector/filter.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n/// Bloom filter for relative selectors.\nuse rustc_hash::FxHashMap;\n\nuse crate::bloom::BloomFilter;\nuse crate::context::QuirksMode;\nuse crate::parser::{collect_selector_hashes, RelativeSelector, RelativeSelectorMatchHint};\nuse crate::tree::{Element, OpaqueElement};\nuse crate::SelectorImpl;\n\nenum Entry {\n /// Filter lookup happened once. Construction of the filter is expensive,\n /// so this is set when the element for subtree traversal is encountered.\n Lookup,\n /// Filter lookup happened more than once, and the filter for this element's\n /// subtree traversal is constructed. Could use special handlings for pseudo-classes\n /// such as `:hover` and `:focus`, see Bug 1845503.\n HasFilter(Box),\n}\n\n#[derive(Clone, Copy, Hash, Eq, PartialEq)]\nenum TraversalKind {\n Children,\n Descendants,\n}\n\nfn add_to_filter(element: &E, filter: &mut BloomFilter, kind: TraversalKind) -> bool {\n let mut child = element.first_element_child();\n while let Some(e) = child {\n if !e.add_element_unique_hashes(filter) {\n return false;\n }\n if kind == TraversalKind::Descendants {\n if !add_to_filter(&e, filter, kind) {\n return false;\n }\n }\n child = e.next_sibling_element();\n }\n true\n}\n\n#[derive(Clone, Copy, Hash, Eq, PartialEq)]\nstruct Key(OpaqueElement, TraversalKind);\n\n/// Map of bloom filters for fast-rejecting relative selectors.\n#[derive(Default)]\npub struct RelativeSelectorFilterMap {\n map: FxHashMap,\n}\n\nfn fast_reject(\n selector: &RelativeSelector,\n quirks_mode: QuirksMode,\n filter: &BloomFilter,\n) -> bool {\n let mut hashes = [0u32; 4];\n let mut len = 0;\n // For inner selectors, we only collect from the single rightmost compound.\n // This is because inner selectors can cause breakouts: e.g. `.anchor:has(:is(.a .b) .c)`\n // can match when `.a` is the ancestor of `.anchor`. Including `.a` would possibly fast\n // reject the subtree for not having `.a`, even if the selector would match.\n // Technically, if the selector's traversal is non-sibling subtree, we can traverse\n // inner selectors up to the point where a descendant/child combinator is encountered\n // (e.g. In `.anchor:has(:is(.a ~ .b) .c)`, `.a` is guaranteed to be the a descendant\n // of `.anchor`). While that can be separately handled, well, this is simpler.\n collect_selector_hashes(\n selector.selector.iter(),\n quirks_mode,\n &mut hashes,\n &mut len,\n |s| s.iter(),\n );\n for i in 0..len {\n if !filter.might_contain_hash(hashes[i]) {\n // Definitely rejected.\n return true;\n }\n }\n false\n}\n\nimpl RelativeSelectorFilterMap {\n fn get_filter(&mut self, element: &E, kind: TraversalKind) -> Option<&BloomFilter> {\n // Insert flag to indicate that we looked up the filter once, and\n // create the filter if and only if that flag is there.\n let key = Key(element.opaque(), kind);\n let entry = self\n .map\n .entry(key)\n .and_modify(|entry| {\n if !matches!(entry, Entry::Lookup) {\n return;\n }\n let mut filter = BloomFilter::new();\n // Go through all children/descendants of this element and add their hashes.\n if add_to_filter(element, &mut filter, kind) {\n *entry = Entry::HasFilter(Box::new(filter));\n }\n })\n .or_insert(Entry::Lookup);\n match entry {\n Entry::Lookup => None,\n Entry::HasFilter(ref filter) => Some(filter.as_ref()),\n }\n }\n\n /// Potentially reject the given selector for this element.\n /// This may seem redundant in presence of the cache, but the cache keys into the\n /// selector-element pair specifically, while this filter keys to the element\n /// and the traversal kind, so it is useful for handling multiple selectors\n /// that effectively end up looking at the same(-ish, for siblings) subtree.\n pub fn fast_reject(\n &mut self,\n element: &E,\n selector: &RelativeSelector,\n quirks_mode: QuirksMode,\n ) -> bool {\n if matches!(\n selector.match_hint,\n RelativeSelectorMatchHint::InNextSibling\n ) {\n // Don't bother.\n return false;\n }\n let is_sibling = matches!(\n selector.match_hint,\n RelativeSelectorMatchHint::InSibling\n | RelativeSelectorMatchHint::InNextSiblingSubtree\n | RelativeSelectorMatchHint::InSiblingSubtree\n );\n let is_subtree = matches!(\n selector.match_hint,\n RelativeSelectorMatchHint::InSubtree\n | RelativeSelectorMatchHint::InNextSiblingSubtree\n | RelativeSelectorMatchHint::InSiblingSubtree\n );\n let kind = if is_subtree {\n TraversalKind::Descendants\n } else {\n TraversalKind::Children\n };\n if is_sibling {\n // Contain the entirety of the parent's children/subtree in the filter, and use that.\n // This is less likely to reject, especially for sibling subtree matches; however, it's less\n // expensive memory-wise, compared to storing filters for each sibling.\n element.parent_element().map_or(false, |parent| {\n self.get_filter(&parent, kind)\n .map_or(false, |filter| fast_reject(selector, quirks_mode, filter))\n })\n } else {\n self.get_filter(element, kind)\n .map_or(false, |filter| fast_reject(selector, quirks_mode, filter))\n }\n }\n}\n" }, { "path": "selectors/relative_selector/mod.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\npub mod cache;\npub mod filter;\n" }, { "path": "selectors/sink.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! Small helpers to abstract over different containers.\n#![deny(missing_docs)]\n\nuse smallvec::{Array, SmallVec};\n\n/// A trait to abstract over a `push` method that may be implemented for\n/// different kind of types.\n///\n/// Used to abstract over `Array`, `SmallVec` and `Vec`, and also to implement a\n/// type which `push` method does only tweak a byte when we only need to check\n/// for the presence of something.\npub trait Push {\n /// Push a value into self.\n fn push(&mut self, value: T);\n}\n\nimpl Push for Vec {\n fn push(&mut self, value: T) {\n Vec::push(self, value);\n }\n}\n\nimpl Push for SmallVec {\n fn push(&mut self, value: A::Item) {\n SmallVec::push(self, value);\n }\n}\n" }, { "path": "selectors/tree.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! Traits that nodes must implement. Breaks the otherwise-cyclic dependency\n//! between layout and style.\n\nuse crate::attr::{AttrSelectorOperation, CaseSensitivity, NamespaceConstraint};\nuse crate::bloom::BloomFilter;\nuse crate::matching::{ElementSelectorFlags, MatchingContext};\nuse crate::parser::SelectorImpl;\nuse std::fmt::Debug;\nuse std::ptr::NonNull;\n\n/// Opaque representation of an Element, for identity comparisons.\n#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]\npub struct OpaqueElement(NonNull<()>);\n\nunsafe impl Send for OpaqueElement {}\n// This should be safe given that we do not provide a way to recover\n// the original reference.\nunsafe impl Sync for OpaqueElement {}\n\nimpl OpaqueElement {\n /// Creates a new OpaqueElement from an arbitrarily-typed pointer.\n pub fn new(ptr: &T) -> Self {\n unsafe {\n OpaqueElement(NonNull::new_unchecked(\n ptr as *const T as *const () as *mut (),\n ))\n }\n }\n\n /// Creates a new OpaqueElement from a type-erased non-null pointer\n pub fn from_non_null_ptr(ptr: NonNull<()>) -> Self {\n Self(ptr)\n }\n\n /// Returns a const ptr to the contained reference. Unsafe especially\n /// since Element can be recovered and potentially-mutated.\n pub unsafe fn as_const_ptr(&self) -> *const T {\n self.0.as_ptr() as *const T\n }\n}\n\npub trait Element: Sized + Clone + Debug {\n type Impl: SelectorImpl;\n\n /// Converts self into an opaque representation.\n fn opaque(&self) -> OpaqueElement;\n\n fn parent_element(&self) -> Option;\n\n /// Whether the parent node of this element is a shadow root.\n fn parent_node_is_shadow_root(&self) -> bool;\n\n /// The host of the containing shadow root, if any.\n fn containing_shadow_host(&self) -> Option;\n\n /// The parent of a given pseudo-element, after matching a pseudo-element\n /// selector.\n ///\n /// This is guaranteed to be called in a pseudo-element.\n fn pseudo_element_originating_element(&self) -> Option {\n debug_assert!(self.is_pseudo_element());\n self.parent_element()\n }\n\n /// Whether we're matching on a pseudo-element.\n fn is_pseudo_element(&self) -> bool;\n\n /// Skips non-element nodes\n fn prev_sibling_element(&self) -> Option;\n\n /// Skips non-element nodes\n fn next_sibling_element(&self) -> Option;\n\n /// Skips non-element nodes\n fn first_element_child(&self) -> Option;\n\n fn is_html_element_in_html_document(&self) -> bool;\n\n fn has_local_name(&self, local_name: &::BorrowedLocalName) -> bool;\n\n /// Empty string for no namespace\n fn has_namespace(&self, ns: &::BorrowedNamespaceUrl) -> bool;\n\n /// Whether this element and the `other` element have the same local name and namespace.\n fn is_same_type(&self, other: &Self) -> bool;\n\n fn attr_matches(\n &self,\n ns: &NamespaceConstraint<&::NamespaceUrl>,\n local_name: &::LocalName,\n operation: &AttrSelectorOperation<&::AttrValue>,\n ) -> bool;\n\n fn has_attr_in_no_namespace(\n &self,\n local_name: &::LocalName,\n ) -> bool {\n self.attr_matches(\n &NamespaceConstraint::Specific(&crate::parser::namespace_empty_string::()),\n local_name,\n &AttrSelectorOperation::Exists,\n )\n }\n\n fn match_non_ts_pseudo_class(\n &self,\n pc: &::NonTSPseudoClass,\n context: &mut MatchingContext,\n ) -> bool;\n\n fn match_pseudo_element(\n &self,\n pe: &::PseudoElement,\n context: &mut MatchingContext,\n ) -> bool;\n\n /// Sets selector flags on the elemnt itself or the parent, depending on the\n /// flags, which indicate what kind of work may need to be performed when\n /// DOM state changes.\n fn apply_selector_flags(&self, flags: ElementSelectorFlags);\n\n /// Whether this element is a `link`.\n fn is_link(&self) -> bool;\n\n /// Returns whether the element is an HTML element.\n fn is_html_slot_element(&self) -> bool;\n\n /// Returns the assigned element this element is assigned to.\n ///\n /// Necessary for the `::slotted` pseudo-class.\n fn assigned_slot(&self) -> Option {\n None\n }\n\n fn has_id(\n &self,\n id: &::Identifier,\n case_sensitivity: CaseSensitivity,\n ) -> bool;\n\n fn has_class(\n &self,\n name: &::Identifier,\n case_sensitivity: CaseSensitivity,\n ) -> bool;\n\n fn has_custom_state(&self, name: &::Identifier) -> bool;\n\n /// Returns the mapping from the `exportparts` attribute in the reverse\n /// direction, that is, in an outer-tree -> inner-tree direction.\n fn imported_part(\n &self,\n name: &::Identifier,\n ) -> Option<::Identifier>;\n\n fn is_part(&self, name: &::Identifier) -> bool;\n\n /// Returns whether this element matches `:empty`.\n ///\n /// That is, whether it does not contain any child element or any non-zero-length text node.\n /// See http://dev.w3.org/csswg/selectors-3/#empty-pseudo\n fn is_empty(&self) -> bool;\n\n /// Returns whether this element matches `:root`,\n /// i.e. whether it is the root element of a document.\n ///\n /// Note: this can be false even if `.parent_element()` is `None`\n /// if the parent node is a `DocumentFragment`.\n fn is_root(&self) -> bool;\n\n /// Returns whether this element should ignore matching nth child\n /// selector.\n fn ignores_nth_child_selectors(&self) -> bool {\n false\n }\n\n /// Add hashes unique to this element to the given filter, returning true\n /// if any got added.\n fn add_element_unique_hashes(&self, filter: &mut BloomFilter) -> bool;\n}\n" }, { "path": "selectors/visitor.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! Visitor traits for selectors.\n\n#![deny(missing_docs)]\n\nuse crate::attr::NamespaceConstraint;\nuse crate::parser::{Combinator, Component, RelativeSelector, Selector, SelectorImpl};\nuse bitflags::bitflags;\n\n/// A trait to visit selector properties.\n///\n/// All the `visit_foo` methods return a boolean indicating whether the\n/// traversal should continue or not.\npub trait SelectorVisitor: Sized {\n /// The selector implementation this visitor wants to visit.\n type Impl: SelectorImpl;\n\n /// Visit an attribute selector that may match (there are other selectors\n /// that may never match, like those containing whitespace or the empty\n /// string).\n fn visit_attribute_selector(\n &mut self,\n _namespace: &NamespaceConstraint<&::NamespaceUrl>,\n _local_name: &::LocalName,\n _local_name_lower: &::LocalName,\n ) -> bool {\n true\n }\n\n /// Visit a simple selector.\n fn visit_simple_selector(&mut self, _: &Component) -> bool {\n true\n }\n\n /// Visit a nested relative selector list. The caller is responsible to call visit\n /// into the internal selectors if / as needed.\n ///\n /// The default implementation skips it altogether.\n fn visit_relative_selector_list(&mut self, _list: &[RelativeSelector]) -> bool {\n true\n }\n\n /// Visit a nested selector list. The caller is responsible to call visit\n /// into the internal selectors if / as needed.\n ///\n /// The default implementation does this.\n fn visit_selector_list(\n &mut self,\n _list_kind: SelectorListKind,\n list: &[Selector],\n ) -> bool {\n for nested in list {\n if !nested.visit(self) {\n return false;\n }\n }\n true\n }\n\n /// Visits a complex selector.\n ///\n /// Gets the combinator to the right of the selector, or `None` if the\n /// selector is the rightmost one.\n fn visit_complex_selector(&mut self, _combinator_to_right: Option) -> bool {\n true\n }\n}\n\nbitflags! {\n /// The kinds of components the visitor is visiting the selector list of, if any\n #[derive(Clone, Copy, Default)]\n pub struct SelectorListKind: u8 {\n /// The visitor is inside :not(..)\n const NEGATION = 1 << 0;\n /// The visitor is inside :is(..)\n const IS = 1 << 1;\n /// The visitor is inside :where(..)\n const WHERE = 1 << 2;\n /// The visitor is inside :nth-child(.. of ) or\n /// :nth-last-child(.. of )\n const NTH_OF = 1 << 3;\n /// The visitor is inside :has(..)\n const HAS = 1 << 4;\n }\n}\n\nimpl SelectorListKind {\n /// Construct a SelectorListKind for the corresponding component.\n pub fn from_component(component: &Component) -> Self {\n match component {\n Component::Negation(_) => SelectorListKind::NEGATION,\n Component::Is(_) => SelectorListKind::IS,\n Component::Where(_) => SelectorListKind::WHERE,\n Component::NthOf(_) => SelectorListKind::NTH_OF,\n _ => SelectorListKind::empty(),\n }\n }\n\n /// Whether the visitor is inside :not(..)\n pub fn in_negation(&self) -> bool {\n self.intersects(SelectorListKind::NEGATION)\n }\n\n /// Whether the visitor is inside :is(..)\n pub fn in_is(&self) -> bool {\n self.intersects(SelectorListKind::IS)\n }\n\n /// Whether the visitor is inside :where(..)\n pub fn in_where(&self) -> bool {\n self.intersects(SelectorListKind::WHERE)\n }\n\n /// Whether the visitor is inside :nth-child(.. of ) or\n /// :nth-last-child(.. of )\n pub fn in_nth_of(&self) -> bool {\n self.intersects(SelectorListKind::NTH_OF)\n }\n\n /// Whether the visitor is inside :has(..)\n pub fn in_has(&self) -> bool {\n self.intersects(SelectorListKind::HAS)\n }\n\n /// Whether this nested selector is relevant for nth-of dependencies.\n pub fn relevant_to_nth_of_dependencies(&self) -> bool {\n // Order of nesting for `:has` and `:nth-child(.. of ..)` doesn't matter, because:\n // * `:has(:nth-child(.. of ..))`: The location of the anchoring element is\n // independent from where `:nth-child(.. of ..)` is applied.\n // * `:nth-child(.. of :has(..))`: Invalidations inside `:has` must first use the\n // `:has` machinary to find the anchor, then carry out the remaining invalidation.\n self.in_nth_of() && !self.in_has()\n }\n}\n" }, { "path": "servo_arc/Cargo.toml", "content": "[package]\nname = \"servo_arc\"\nversion = \"0.4.3\"\nauthors = [\"The Servo Project Developers\"]\nlicense = \"MIT OR Apache-2.0\"\nrepository = \"https://github.com/servo/stylo\"\ndescription = \"A fork of std::sync::Arc with some extra functionality and without weak references\"\nedition = \"2021\"\nreadme = \"../README.md\"\n\n[lib]\nname = \"servo_arc\"\npath = \"lib.rs\"\n\n[features]\ndefault = [\"track_alloc_size\"]\ngecko_refcount_logging = []\nservo = [\"serde\", \"track_alloc_size\"]\ntrack_alloc_size = []\n\n[dependencies]\nserde = { version = \"1.0\", optional = true }\nstable_deref_trait = \"1.0.0\"\n" }, { "path": "servo_arc/LICENSE-APACHE", "content": " Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\nTERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\nEND OF TERMS AND CONDITIONS\n\nAPPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"[]\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\nCopyright [yyyy] [name of copyright owner]\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n\thttp://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n" }, { "path": "servo_arc/LICENSE-MIT", "content": "Permission is hereby granted, free of charge, to any\nperson obtaining a copy of this software and associated\ndocumentation files (the \"Software\"), to deal in the\nSoftware without restriction, including without\nlimitation the rights to use, copy, modify, merge,\npublish, distribute, sublicense, and/or sell copies of\nthe Software, and to permit persons to whom the Software\nis furnished to do so, subject to the following\nconditions:\n\nThe above copyright notice and this permission notice\nshall be included in all copies or substantial portions\nof the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF\nANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED\nTO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A\nPARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT\nSHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\nCLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\nOF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR\nIN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\nDEALINGS IN THE SOFTWARE.\n" }, { "path": "servo_arc/lib.rs", "content": "// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 or the MIT license\n// , at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Fork of Arc for Servo. This has the following advantages over std::sync::Arc:\n//!\n//! * We don't waste storage on the weak reference count.\n//! * We don't do extra RMU operations to handle the possibility of weak references.\n//! * We can experiment with arena allocation (todo).\n//! * We can add methods to support our custom use cases [1].\n//! * We have support for dynamically-sized types (see from_header_and_iter).\n//! * We have support for thin arcs to unsized types (see ThinArc).\n//! * We have support for references to static data, which don't do any\n//! refcounting.\n//!\n//! [1]: https://bugzilla.mozilla.org/show_bug.cgi?id=1360883\n\n// The semantics of `Arc` are already documented in the Rust docs, so we don't\n// duplicate those here.\n#![allow(missing_docs)]\n\n#[cfg(feature = \"servo\")]\nuse serde::{Deserialize, Serialize};\nuse stable_deref_trait::{CloneStableDeref, StableDeref};\nuse std::alloc::{self, Layout};\nuse std::borrow;\nuse std::cmp::Ordering;\nuse std::fmt;\nuse std::hash::{Hash, Hasher};\nuse std::marker::PhantomData;\nuse std::mem::{self, align_of, size_of};\nuse std::ops::{Deref, DerefMut};\nuse std::os::raw::c_void;\nuse std::process;\nuse std::ptr;\nuse std::sync::atomic;\nuse std::sync::atomic::Ordering::{Acquire, Relaxed, Release};\nuse std::{isize, usize};\n\n/// A soft limit on the amount of references that may be made to an `Arc`.\n///\n/// Going above this limit will abort your program (although not\n/// necessarily) at _exactly_ `MAX_REFCOUNT + 1` references.\nconst MAX_REFCOUNT: usize = (isize::MAX) as usize;\n\n/// Special refcount value that means the data is not reference counted,\n/// and that the `Arc` is really acting as a read-only static reference.\nconst STATIC_REFCOUNT: usize = usize::MAX;\n\n/// An atomically reference counted shared pointer\n///\n/// See the documentation for [`Arc`] in the standard library. Unlike the\n/// standard library `Arc`, this `Arc` does not support weak reference counting.\n///\n/// See the discussion in https://github.com/rust-lang/rust/pull/60594 for the\n/// usage of PhantomData.\n///\n/// [`Arc`]: https://doc.rust-lang.org/stable/std/sync/struct.Arc.html\n///\n/// cbindgen:derive-eq=false\n/// cbindgen:derive-neq=false\n#[repr(C)]\npub struct Arc {\n p: ptr::NonNull>,\n phantom: PhantomData,\n}\n\n/// An `Arc` that is known to be uniquely owned\n///\n/// When `Arc`s are constructed, they are known to be\n/// uniquely owned. In such a case it is safe to mutate\n/// the contents of the `Arc`. Normally, one would just handle\n/// this by mutating the data on the stack before allocating the\n/// `Arc`, however it's possible the data is large or unsized\n/// and you need to heap-allocate it earlier in such a way\n/// that it can be freely converted into a regular `Arc` once you're\n/// done.\n///\n/// `UniqueArc` exists for this purpose, when constructed it performs\n/// the same allocations necessary for an `Arc`, however it allows mutable access.\n/// Once the mutation is finished, you can call `.shareable()` and get a regular `Arc`\n/// out of it.\n///\n/// Ignore the doctest below there's no way to skip building with refcount\n/// logging during doc tests (see rust-lang/rust#45599).\n///\n/// ```rust,ignore\n/// # use servo_arc::UniqueArc;\n/// let data = [1, 2, 3, 4, 5];\n/// let mut x = UniqueArc::new(data);\n/// x[4] = 7; // mutate!\n/// let y = x.shareable(); // y is an Arc\n/// ```\npub struct UniqueArc(Arc);\n\nimpl UniqueArc {\n #[inline]\n /// Construct a new UniqueArc\n pub fn new(data: T) -> Self {\n UniqueArc(Arc::new(data))\n }\n\n /// Construct an uninitialized arc\n #[inline]\n pub fn new_uninit() -> UniqueArc> {\n unsafe {\n let layout = Layout::new::>>();\n let ptr = alloc::alloc(layout);\n let mut p = ptr::NonNull::new(ptr)\n .unwrap_or_else(|| alloc::handle_alloc_error(layout))\n .cast::>>();\n ptr::write(&mut p.as_mut().count, atomic::AtomicUsize::new(1));\n #[cfg(feature = \"track_alloc_size\")]\n ptr::write(&mut p.as_mut().alloc_size, layout.size());\n\n #[cfg(feature = \"gecko_refcount_logging\")]\n {\n NS_LogCtor(p.as_ptr() as *mut _, b\"ServoArc\\0\".as_ptr() as *const _, 8)\n }\n\n UniqueArc(Arc {\n p,\n phantom: PhantomData,\n })\n }\n }\n\n #[inline]\n /// Convert to a shareable Arc once we're done mutating it\n pub fn shareable(self) -> Arc {\n self.0\n }\n}\n\nimpl UniqueArc> {\n /// Convert to an initialized Arc.\n #[inline]\n pub unsafe fn assume_init(this: Self) -> UniqueArc {\n UniqueArc(Arc {\n p: mem::ManuallyDrop::new(this).0.p.cast(),\n phantom: PhantomData,\n })\n }\n}\n\nimpl Deref for UniqueArc {\n type Target = T;\n fn deref(&self) -> &T {\n &*self.0\n }\n}\n\nimpl DerefMut for UniqueArc {\n fn deref_mut(&mut self) -> &mut T {\n // We know this to be uniquely owned\n unsafe { &mut (*self.0.ptr()).data }\n }\n}\n\nunsafe impl Send for Arc {}\nunsafe impl Sync for Arc {}\n\n/// The object allocated by an Arc\n///\n/// See https://github.com/mozilla/cbindgen/issues/937 for the derive-{eq,neq}=false. But we don't\n/// use those anyways so we can just disable them.\n/// cbindgen:derive-eq=false\n/// cbindgen:derive-neq=false\n#[repr(C)]\nstruct ArcInner {\n count: atomic::AtomicUsize,\n // NOTE(emilio): This needs to be here so that HeaderSlice<> is deallocated properly if the\n // allocator relies on getting the right Layout. We don't need to track the right alignment,\n // since we know that statically.\n //\n // This member could be completely avoided once min_specialization feature is stable (by\n // implementing a trait for HeaderSlice that gives you the right layout). For now, servo-only\n // since Gecko doesn't need it (its allocator doesn't need the size for the alignments we care\n // about). See https://github.com/rust-lang/rust/issues/31844.\n #[cfg(feature = \"track_alloc_size\")]\n alloc_size: usize,\n data: T,\n}\n\nunsafe impl Send for ArcInner {}\nunsafe impl Sync for ArcInner {}\n\n/// Computes the offset of the data field within ArcInner.\nfn data_offset() -> usize {\n let size = size_of::>();\n let align = align_of::();\n // https://github.com/rust-lang/rust/blob/1.36.0/src/libcore/alloc.rs#L187-L207\n size.wrapping_add(align).wrapping_sub(1) & !align.wrapping_sub(1)\n}\n\nimpl Arc {\n /// Construct an `Arc`\n #[inline]\n pub fn new(data: T) -> Self {\n let layout = Layout::new::>();\n let p = unsafe {\n let ptr = ptr::NonNull::new(alloc::alloc(layout))\n .unwrap_or_else(|| alloc::handle_alloc_error(layout))\n .cast::>();\n ptr::write(\n ptr.as_ptr(),\n ArcInner {\n count: atomic::AtomicUsize::new(1),\n #[cfg(feature = \"track_alloc_size\")]\n alloc_size: layout.size(),\n data,\n },\n );\n ptr\n };\n\n #[cfg(feature = \"gecko_refcount_logging\")]\n unsafe {\n // FIXME(emilio): Would be so amazing to have\n // std::intrinsics::type_name() around, so that we could also report\n // a real size.\n NS_LogCtor(p.as_ptr() as *mut _, b\"ServoArc\\0\".as_ptr() as *const _, 8);\n }\n\n Arc {\n p,\n phantom: PhantomData,\n }\n }\n\n /// Construct an intentionally-leaked arc.\n #[inline]\n pub fn new_leaked(data: T) -> Self {\n let arc = Self::new(data);\n arc.mark_as_intentionally_leaked();\n arc\n }\n\n /// Convert the Arc to a raw pointer, suitable for use across FFI\n ///\n /// Note: This returns a pointer to the data T, which is offset in the allocation.\n #[inline]\n pub fn into_raw(this: Self) -> *const T {\n let ptr = unsafe { &((*this.ptr()).data) as *const _ };\n mem::forget(this);\n ptr\n }\n\n /// Reconstruct the Arc from a raw pointer obtained from into_raw()\n ///\n /// Note: This raw pointer will be offset in the allocation and must be preceded\n /// by the atomic count.\n #[inline]\n pub unsafe fn from_raw(ptr: *const T) -> Self {\n // To find the corresponding pointer to the `ArcInner` we need\n // to subtract the offset of the `data` field from the pointer.\n let ptr = (ptr as *const u8).sub(data_offset::());\n Arc {\n p: ptr::NonNull::new_unchecked(ptr as *mut ArcInner),\n phantom: PhantomData,\n }\n }\n\n /// Like from_raw, but returns an addrefed arc instead.\n #[inline]\n pub unsafe fn from_raw_addrefed(ptr: *const T) -> Self {\n let arc = Self::from_raw(ptr);\n mem::forget(arc.clone());\n arc\n }\n\n /// Create a new static Arc (one that won't reference count the object)\n /// and place it in the allocation provided by the specified `alloc`\n /// function.\n ///\n /// `alloc` must return a pointer into a static allocation suitable for\n /// storing data with the `Layout` passed into it. The pointer returned by\n /// `alloc` will not be freed.\n #[inline]\n pub unsafe fn new_static(alloc: F, data: T) -> Arc\n where\n F: FnOnce(Layout) -> *mut u8,\n {\n let layout = Layout::new::>();\n let ptr = alloc(layout) as *mut ArcInner;\n\n let x = ArcInner {\n count: atomic::AtomicUsize::new(STATIC_REFCOUNT),\n #[cfg(feature = \"track_alloc_size\")]\n alloc_size: layout.size(),\n data,\n };\n\n ptr::write(ptr, x);\n\n Arc {\n p: ptr::NonNull::new_unchecked(ptr),\n phantom: PhantomData,\n }\n }\n\n /// Produce a pointer to the data that can be converted back\n /// to an Arc. This is basically an `&Arc`, without the extra indirection.\n /// It has the benefits of an `&T` but also knows about the underlying refcount\n /// and can be converted into more `Arc`s if necessary.\n #[inline]\n pub fn borrow_arc<'a>(&'a self) -> ArcBorrow<'a, T> {\n ArcBorrow(&**self)\n }\n\n /// Returns the address on the heap of the Arc itself -- not the T within it -- for memory\n /// reporting.\n ///\n /// If this is a static reference, this returns null.\n pub fn heap_ptr(&self) -> *const c_void {\n if self.inner().count.load(Relaxed) == STATIC_REFCOUNT {\n ptr::null()\n } else {\n self.p.as_ptr() as *const ArcInner as *const c_void\n }\n }\n}\n\nimpl Arc {\n #[inline]\n fn inner(&self) -> &ArcInner {\n // This unsafety is ok because while this arc is alive we're guaranteed\n // that the inner pointer is valid. Furthermore, we know that the\n // `ArcInner` structure itself is `Sync` because the inner data is\n // `Sync` as well, so we're ok loaning out an immutable pointer to these\n // contents.\n unsafe { &*self.ptr() }\n }\n\n #[inline(always)]\n fn record_drop(&self) {\n #[cfg(feature = \"gecko_refcount_logging\")]\n unsafe {\n NS_LogDtor(self.ptr() as *mut _, b\"ServoArc\\0\".as_ptr() as *const _, 8);\n }\n }\n\n /// Marks this `Arc` as intentionally leaked for the purposes of refcount\n /// logging.\n ///\n /// It's a logic error to call this more than once, but it's not unsafe, as\n /// it'd just report negative leaks.\n #[inline(always)]\n pub fn mark_as_intentionally_leaked(&self) {\n self.record_drop();\n }\n\n // Non-inlined part of `drop`. Just invokes the destructor and calls the\n // refcount logging machinery if enabled.\n #[inline(never)]\n unsafe fn drop_slow(&mut self) {\n self.record_drop();\n let inner = self.ptr();\n\n let layout = Layout::for_value(&*inner);\n #[cfg(feature = \"track_alloc_size\")]\n let layout = Layout::from_size_align_unchecked((*inner).alloc_size, layout.align());\n\n std::ptr::drop_in_place(inner);\n alloc::dealloc(inner as *mut _, layout);\n }\n\n /// Test pointer equality between the two Arcs, i.e. they must be the _same_\n /// allocation\n #[inline]\n pub fn ptr_eq(this: &Self, other: &Self) -> bool {\n this.raw_ptr() == other.raw_ptr()\n }\n\n fn ptr(&self) -> *mut ArcInner {\n self.p.as_ptr()\n }\n\n /// Returns a raw ptr to the underlying allocation.\n pub fn raw_ptr(&self) -> ptr::NonNull<()> {\n self.p.cast()\n }\n}\n\n#[cfg(feature = \"gecko_refcount_logging\")]\nextern \"C\" {\n fn NS_LogCtor(\n aPtr: *mut std::os::raw::c_void,\n aTypeName: *const std::os::raw::c_char,\n aSize: u32,\n );\n fn NS_LogDtor(\n aPtr: *mut std::os::raw::c_void,\n aTypeName: *const std::os::raw::c_char,\n aSize: u32,\n );\n}\n\nimpl Clone for Arc {\n #[inline]\n fn clone(&self) -> Self {\n // NOTE(emilio): If you change anything here, make sure that the\n // implementation in layout/style/ServoStyleConstsInlines.h matches!\n //\n // Using a relaxed ordering to check for STATIC_REFCOUNT is safe, since\n // `count` never changes between STATIC_REFCOUNT and other values.\n if self.inner().count.load(Relaxed) != STATIC_REFCOUNT {\n // Using a relaxed ordering is alright here, as knowledge of the\n // original reference prevents other threads from erroneously deleting\n // the object.\n //\n // As explained in the [Boost documentation][1], Increasing the\n // reference counter can always be done with memory_order_relaxed: New\n // references to an object can only be formed from an existing\n // reference, and passing an existing reference from one thread to\n // another must already provide any required synchronization.\n //\n // [1]: (www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html)\n let old_size = self.inner().count.fetch_add(1, Relaxed);\n\n // However we need to guard against massive refcounts in case someone\n // is `mem::forget`ing Arcs. If we don't do this the count can overflow\n // and users will use-after free. We racily saturate to `isize::MAX` on\n // the assumption that there aren't ~2 billion threads incrementing\n // the reference count at once. This branch will never be taken in\n // any realistic program.\n //\n // We abort because such a program is incredibly degenerate, and we\n // don't care to support it.\n if old_size > MAX_REFCOUNT {\n process::abort();\n }\n }\n\n unsafe {\n Arc {\n p: ptr::NonNull::new_unchecked(self.ptr()),\n phantom: PhantomData,\n }\n }\n }\n}\n\nimpl Deref for Arc {\n type Target = T;\n\n #[inline]\n fn deref(&self) -> &T {\n &self.inner().data\n }\n}\n\nimpl Arc {\n /// Makes a mutable reference to the `Arc`, cloning if necessary\n ///\n /// This is functionally equivalent to [`Arc::make_mut`][mm] from the standard library.\n ///\n /// If this `Arc` is uniquely owned, `make_mut()` will provide a mutable\n /// reference to the contents. If not, `make_mut()` will create a _new_ `Arc`\n /// with a copy of the contents, update `this` to point to it, and provide\n /// a mutable reference to its contents.\n ///\n /// This is useful for implementing copy-on-write schemes where you wish to\n /// avoid copying things if your `Arc` is not shared.\n ///\n /// [mm]: https://doc.rust-lang.org/stable/std/sync/struct.Arc.html#method.make_mut\n #[inline]\n pub fn make_mut(this: &mut Self) -> &mut T {\n if !this.is_unique() {\n // Another pointer exists; clone\n *this = Arc::new((**this).clone());\n }\n\n unsafe {\n // This unsafety is ok because we're guaranteed that the pointer\n // returned is the *only* pointer that will ever be returned to T. Our\n // reference count is guaranteed to be 1 at this point, and we required\n // the Arc itself to be `mut`, so we're returning the only possible\n // reference to the inner data.\n &mut (*this.ptr()).data\n }\n }\n}\n\nimpl Arc {\n /// Provides mutable access to the contents _if_ the `Arc` is uniquely owned.\n #[inline]\n pub fn get_mut(this: &mut Self) -> Option<&mut T> {\n if this.is_unique() {\n unsafe {\n // See make_mut() for documentation of the threadsafety here.\n Some(&mut (*this.ptr()).data)\n }\n } else {\n None\n }\n }\n\n /// Whether or not the `Arc` is a static reference.\n #[inline]\n pub fn is_static(&self) -> bool {\n // Using a relaxed ordering to check for STATIC_REFCOUNT is safe, since\n // `count` never changes between STATIC_REFCOUNT and other values.\n self.inner().count.load(Relaxed) == STATIC_REFCOUNT\n }\n\n /// Whether or not the `Arc` is uniquely owned (is the refcount 1?) and not\n /// a static reference.\n #[inline]\n pub fn is_unique(&self) -> bool {\n // See the extensive discussion in [1] for why this needs to be Acquire.\n //\n // [1] https://github.com/servo/servo/issues/21186\n self.inner().count.load(Acquire) == 1\n }\n}\n\nimpl Drop for Arc {\n #[inline]\n fn drop(&mut self) {\n // NOTE(emilio): If you change anything here, make sure that the\n // implementation in layout/style/ServoStyleConstsInlines.h matches!\n if self.is_static() {\n return;\n }\n\n // Because `fetch_sub` is already atomic, we do not need to synchronize\n // with other threads unless we are going to delete the object.\n if self.inner().count.fetch_sub(1, Release) != 1 {\n return;\n }\n\n // FIXME(bholley): Use the updated comment when [2] is merged.\n //\n // This load is needed to prevent reordering of use of the data and\n // deletion of the data. Because it is marked `Release`, the decreasing\n // of the reference count synchronizes with this `Acquire` load. This\n // means that use of the data happens before decreasing the reference\n // count, which happens before this load, which happens before the\n // deletion of the data.\n //\n // As explained in the [Boost documentation][1],\n //\n // > It is important to enforce any possible access to the object in one\n // > thread (through an existing reference) to *happen before* deleting\n // > the object in a different thread. This is achieved by a \"release\"\n // > operation after dropping a reference (any access to the object\n // > through this reference must obviously happened before), and an\n // > \"acquire\" operation before deleting the object.\n //\n // [1]: (www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html)\n // [2]: https://github.com/rust-lang/rust/pull/41714\n self.inner().count.load(Acquire);\n\n unsafe {\n self.drop_slow();\n }\n }\n}\n\nimpl PartialEq for Arc {\n fn eq(&self, other: &Arc) -> bool {\n Self::ptr_eq(self, other) || *(*self) == *(*other)\n }\n\n fn ne(&self, other: &Arc) -> bool {\n !Self::ptr_eq(self, other) && *(*self) != *(*other)\n }\n}\n\nimpl PartialOrd for Arc {\n fn partial_cmp(&self, other: &Arc) -> Option {\n (**self).partial_cmp(&**other)\n }\n\n fn lt(&self, other: &Arc) -> bool {\n *(*self) < *(*other)\n }\n\n fn le(&self, other: &Arc) -> bool {\n *(*self) <= *(*other)\n }\n\n fn gt(&self, other: &Arc) -> bool {\n *(*self) > *(*other)\n }\n\n fn ge(&self, other: &Arc) -> bool {\n *(*self) >= *(*other)\n }\n}\nimpl Ord for Arc {\n fn cmp(&self, other: &Arc) -> Ordering {\n (**self).cmp(&**other)\n }\n}\nimpl Eq for Arc {}\n\nimpl fmt::Display for Arc {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n fmt::Display::fmt(&**self, f)\n }\n}\n\nimpl fmt::Debug for Arc {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n fmt::Debug::fmt(&**self, f)\n }\n}\n\nimpl fmt::Pointer for Arc {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n fmt::Pointer::fmt(&self.ptr(), f)\n }\n}\n\nimpl Default for Arc {\n fn default() -> Arc {\n Arc::new(Default::default())\n }\n}\n\nimpl Hash for Arc {\n fn hash(&self, state: &mut H) {\n (**self).hash(state)\n }\n}\n\nimpl From for Arc {\n #[inline]\n fn from(t: T) -> Self {\n Arc::new(t)\n }\n}\n\nimpl borrow::Borrow for Arc {\n #[inline]\n fn borrow(&self) -> &T {\n &**self\n }\n}\n\nimpl AsRef for Arc {\n #[inline]\n fn as_ref(&self) -> &T {\n &**self\n }\n}\n\nunsafe impl StableDeref for Arc {}\nunsafe impl CloneStableDeref for Arc {}\n\n#[cfg(feature = \"servo\")]\nimpl<'de, T: Deserialize<'de>> Deserialize<'de> for Arc {\n fn deserialize(deserializer: D) -> Result, D::Error>\n where\n D: ::serde::de::Deserializer<'de>,\n {\n T::deserialize(deserializer).map(Arc::new)\n }\n}\n\n#[cfg(feature = \"servo\")]\nimpl Serialize for Arc {\n fn serialize(&self, serializer: S) -> Result\n where\n S: ::serde::ser::Serializer,\n {\n (**self).serialize(serializer)\n }\n}\n\n/// Structure to allow Arc-managing some fixed-sized data and a variably-sized\n/// slice in a single allocation.\n///\n/// cbindgen:derive-eq=false\n/// cbindgen:derive-neq=false\n#[derive(Eq)]\n#[repr(C)]\npub struct HeaderSlice {\n /// The fixed-sized data.\n pub header: H,\n\n /// The length of the slice at our end.\n len: usize,\n\n /// The dynamically-sized data.\n data: [T; 0],\n}\n\nimpl PartialEq for HeaderSlice {\n fn eq(&self, other: &Self) -> bool {\n self.header == other.header && self.slice() == other.slice()\n }\n}\n\nimpl Drop for HeaderSlice {\n fn drop(&mut self) {\n unsafe {\n let mut ptr = self.data_mut();\n for _ in 0..self.len {\n std::ptr::drop_in_place(ptr);\n ptr = ptr.offset(1);\n }\n }\n }\n}\n\nimpl fmt::Debug for HeaderSlice {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n f.debug_struct(\"HeaderSlice\")\n .field(\"header\", &self.header)\n .field(\"slice\", &self.slice())\n .finish()\n }\n}\n\nimpl HeaderSlice {\n /// Returns the dynamically sized slice in this HeaderSlice.\n #[inline(always)]\n pub fn slice(&self) -> &[T] {\n unsafe { std::slice::from_raw_parts(self.data(), self.len) }\n }\n\n #[inline(always)]\n fn data(&self) -> *const T {\n std::ptr::addr_of!(self.data) as *const _\n }\n\n #[inline(always)]\n fn data_mut(&mut self) -> *mut T {\n std::ptr::addr_of_mut!(self.data) as *mut _\n }\n\n /// Returns the dynamically sized slice in this HeaderSlice.\n #[inline(always)]\n pub fn slice_mut(&mut self) -> &mut [T] {\n unsafe { std::slice::from_raw_parts_mut(self.data_mut(), self.len) }\n }\n\n /// Returns the len of the slice.\n #[inline(always)]\n pub fn len(&self) -> usize {\n self.len\n }\n}\n\nimpl Arc> {\n /// Creates an Arc for a HeaderSlice using the given header struct and\n /// iterator to generate the slice.\n ///\n /// `is_static` indicates whether to create a static Arc.\n ///\n /// `alloc` is used to get a pointer to the memory into which the\n /// dynamically sized ArcInner> value will be\n /// written. If `is_static` is true, then `alloc` must return a\n /// pointer into some static memory allocation. If it is false,\n /// then `alloc` must return an allocation that can be dellocated\n /// by calling Box::from_raw::>> on it.\n #[inline]\n pub fn from_header_and_iter_alloc(\n alloc: F,\n header: H,\n mut items: I,\n num_items: usize,\n is_static: bool,\n ) -> Self\n where\n F: FnOnce(Layout) -> *mut u8,\n I: Iterator,\n {\n assert_ne!(size_of::(), 0, \"Need to think about ZST\");\n\n let layout = Layout::new::>>();\n debug_assert!(layout.align() >= align_of::());\n debug_assert!(layout.align() >= align_of::());\n let array_layout = Layout::array::(num_items).expect(\"Overflow\");\n let (layout, _offset) = layout.extend(array_layout).expect(\"Overflow\");\n let p = unsafe {\n // Allocate the buffer.\n let buffer = alloc(layout);\n let mut p = ptr::NonNull::new(buffer)\n .unwrap_or_else(|| alloc::handle_alloc_error(layout))\n .cast::>>();\n\n // Write the data.\n //\n // Note that any panics here (i.e. from the iterator) are safe, since\n // we'll just leak the uninitialized memory.\n let count = if is_static {\n atomic::AtomicUsize::new(STATIC_REFCOUNT)\n } else {\n atomic::AtomicUsize::new(1)\n };\n ptr::write(&mut p.as_mut().count, count);\n #[cfg(feature = \"track_alloc_size\")]\n ptr::write(&mut p.as_mut().alloc_size, layout.size());\n ptr::write(&mut p.as_mut().data.header, header);\n ptr::write(&mut p.as_mut().data.len, num_items);\n if num_items != 0 {\n let mut current = std::ptr::addr_of_mut!(p.as_mut().data.data) as *mut T;\n for _ in 0..num_items {\n ptr::write(\n current,\n items\n .next()\n .expect(\"ExactSizeIterator over-reported length\"),\n );\n current = current.offset(1);\n }\n // We should have consumed the buffer exactly, maybe accounting\n // for some padding from the alignment.\n debug_assert!(\n (buffer.add(layout.size()) as usize - current as *mut u8 as usize)\n < layout.align()\n );\n }\n assert!(\n items.next().is_none(),\n \"ExactSizeIterator under-reported length\"\n );\n p\n };\n #[cfg(feature = \"gecko_refcount_logging\")]\n unsafe {\n if !is_static {\n // FIXME(emilio): Would be so amazing to have\n // std::intrinsics::type_name() around.\n NS_LogCtor(p.as_ptr() as *mut _, b\"ServoArc\\0\".as_ptr() as *const _, 8)\n }\n }\n\n // Return the fat Arc.\n assert_eq!(\n size_of::(),\n size_of::(),\n \"The Arc should be thin\"\n );\n\n Arc {\n p,\n phantom: PhantomData,\n }\n }\n\n /// Creates an Arc for a HeaderSlice using the given header struct and iterator to generate the\n /// slice. Panics if num_items doesn't match the number of items.\n #[inline]\n pub fn from_header_and_iter_with_size(header: H, items: I, num_items: usize) -> Self\n where\n I: Iterator,\n {\n Arc::from_header_and_iter_alloc(\n |layout| unsafe { alloc::alloc(layout) },\n header,\n items,\n num_items,\n /* is_static = */ false,\n )\n }\n\n /// Creates an Arc for a HeaderSlice using the given header struct and\n /// iterator to generate the slice. The resulting Arc will be fat.\n #[inline]\n pub fn from_header_and_iter(header: H, items: I) -> Self\n where\n I: Iterator + ExactSizeIterator,\n {\n let len = items.len();\n Self::from_header_and_iter_with_size(header, items, len)\n }\n}\n\n/// This is functionally equivalent to Arc<(H, [T])>\n///\n/// When you create an `Arc` containing a dynamically sized type like a slice, the `Arc` is\n/// represented on the stack as a \"fat pointer\", where the length of the slice is stored alongside\n/// the `Arc`'s pointer. In some situations you may wish to have a thin pointer instead, perhaps\n/// for FFI compatibility or space efficiency. `ThinArc` solves this by storing the length in the\n/// allocation itself, via `HeaderSlice`.\npub type ThinArc = Arc>;\n\n/// See `ArcUnion`. This is a version that works for `ThinArc`s.\npub type ThinArcUnion = ArcUnion, HeaderSlice>;\n\nimpl UniqueArc> {\n #[inline]\n pub fn from_header_and_iter(header: H, items: I) -> Self\n where\n I: Iterator + ExactSizeIterator,\n {\n Self(Arc::from_header_and_iter(header, items))\n }\n\n #[inline]\n pub fn from_header_and_iter_with_size(header: H, items: I, num_items: usize) -> Self\n where\n I: Iterator,\n {\n Self(Arc::from_header_and_iter_with_size(\n header, items, num_items,\n ))\n }\n\n /// Returns a mutable reference to the header.\n pub fn header_mut(&mut self) -> &mut H {\n // We know this to be uniquely owned\n unsafe { &mut (*self.0.ptr()).data.header }\n }\n\n /// Returns a mutable reference to the slice.\n pub fn data_mut(&mut self) -> &mut [T] {\n // We know this to be uniquely owned\n unsafe { (*self.0.ptr()).data.slice_mut() }\n }\n}\n\n/// A \"borrowed `Arc`\". This is a pointer to\n/// a T that is known to have been allocated within an\n/// `Arc`.\n///\n/// This is equivalent in guarantees to `&Arc`, however it is\n/// a bit more flexible. To obtain an `&Arc` you must have\n/// an `Arc` instance somewhere pinned down until we're done with it.\n/// It's also a direct pointer to `T`, so using this involves less pointer-chasing\n///\n/// However, C++ code may hand us refcounted things as pointers to T directly,\n/// so we have to conjure up a temporary `Arc` on the stack each time.\n///\n/// `ArcBorrow` lets us deal with borrows of known-refcounted objects\n/// without needing to worry about where the `Arc` is.\n#[derive(Debug, Eq, PartialEq)]\npub struct ArcBorrow<'a, T: 'a>(&'a T);\n\nimpl<'a, T> Copy for ArcBorrow<'a, T> {}\nimpl<'a, T> Clone for ArcBorrow<'a, T> {\n #[inline]\n fn clone(&self) -> Self {\n *self\n }\n}\n\nimpl<'a, T> ArcBorrow<'a, T> {\n /// Clone this as an `Arc`. This bumps the refcount.\n #[inline]\n pub fn clone_arc(&self) -> Arc {\n let arc = unsafe { Arc::from_raw(self.0) };\n // addref it!\n mem::forget(arc.clone());\n arc\n }\n\n /// For constructing from a reference known to be Arc-backed,\n /// e.g. if we obtain such a reference over FFI\n #[inline]\n pub unsafe fn from_ref(r: &'a T) -> Self {\n ArcBorrow(r)\n }\n\n /// Compare two `ArcBorrow`s via pointer equality. Will only return\n /// true if they come from the same allocation\n pub fn ptr_eq(this: &Self, other: &Self) -> bool {\n this.0 as *const T == other.0 as *const T\n }\n\n /// Temporarily converts |self| into a bonafide Arc and exposes it to the\n /// provided callback. The refcount is not modified.\n #[inline]\n pub fn with_arc(&self, f: F) -> U\n where\n F: FnOnce(&Arc) -> U,\n T: 'static,\n {\n // Synthesize transient Arc, which never touches the refcount.\n let transient = unsafe { mem::ManuallyDrop::new(Arc::from_raw(self.0)) };\n\n // Expose the transient Arc to the callback, which may clone it if it wants.\n let result = f(&transient);\n\n // Forward the result.\n result\n }\n\n /// Similar to deref, but uses the lifetime |a| rather than the lifetime of\n /// self, which is incompatible with the signature of the Deref trait.\n #[inline]\n pub fn get(&self) -> &'a T {\n self.0\n }\n}\n\nimpl<'a, T> Deref for ArcBorrow<'a, T> {\n type Target = T;\n\n #[inline]\n fn deref(&self) -> &T {\n self.0\n }\n}\n\n/// A tagged union that can represent `Arc` or `Arc` while only consuming a\n/// single word. The type is also `NonNull`, and thus can be stored in an Option\n/// without increasing size.\n///\n/// This is functionally equivalent to\n/// `enum ArcUnion { First(Arc), Second(Arc)` but only takes up\n/// up a single word of stack space.\n///\n/// This could probably be extended to support four types if necessary.\npub struct ArcUnion {\n p: ptr::NonNull<()>,\n phantom_a: PhantomData,\n phantom_b: PhantomData,\n}\n\nunsafe impl Send for ArcUnion {}\nunsafe impl Sync for ArcUnion {}\n\nimpl PartialEq for ArcUnion {\n fn eq(&self, other: &Self) -> bool {\n use crate::ArcUnionBorrow::*;\n match (self.borrow(), other.borrow()) {\n (First(x), First(y)) => x == y,\n (Second(x), Second(y)) => x == y,\n (_, _) => false,\n }\n }\n}\n\nimpl Eq for ArcUnion {}\n\n/// This represents a borrow of an `ArcUnion`.\n#[derive(Debug)]\npub enum ArcUnionBorrow<'a, A: 'a, B: 'a> {\n First(ArcBorrow<'a, A>),\n Second(ArcBorrow<'a, B>),\n}\n\nimpl ArcUnion {\n unsafe fn new(ptr: *mut ()) -> Self {\n ArcUnion {\n p: ptr::NonNull::new_unchecked(ptr),\n phantom_a: PhantomData,\n phantom_b: PhantomData,\n }\n }\n\n /// Returns true if the two values are pointer-equal.\n #[inline]\n pub fn ptr_eq(this: &Self, other: &Self) -> bool {\n this.p == other.p\n }\n\n #[inline]\n pub fn ptr(&self) -> ptr::NonNull<()> {\n self.p\n }\n\n /// Returns an enum representing a borrow of either A or B.\n #[inline]\n pub fn borrow(&self) -> ArcUnionBorrow<'_, A, B> {\n if self.is_first() {\n let ptr = self.p.as_ptr() as *const ArcInner;\n let borrow = unsafe { ArcBorrow::from_ref(&(*ptr).data) };\n ArcUnionBorrow::First(borrow)\n } else {\n let ptr = ((self.p.as_ptr() as usize) & !0x1) as *const ArcInner;\n let borrow = unsafe { ArcBorrow::from_ref(&(*ptr).data) };\n ArcUnionBorrow::Second(borrow)\n }\n }\n\n /// Creates an `ArcUnion` from an instance of the first type.\n pub fn from_first(other: Arc) -> Self {\n let union = unsafe { Self::new(other.ptr() as *mut _) };\n mem::forget(other);\n union\n }\n\n /// Creates an `ArcUnion` from an instance of the second type.\n pub fn from_second(other: Arc) -> Self {\n let union = unsafe { Self::new(((other.ptr() as usize) | 0x1) as *mut _) };\n mem::forget(other);\n union\n }\n\n /// Returns true if this `ArcUnion` contains the first type.\n pub fn is_first(&self) -> bool {\n self.p.as_ptr() as usize & 0x1 == 0\n }\n\n /// Returns true if this `ArcUnion` contains the second type.\n pub fn is_second(&self) -> bool {\n !self.is_first()\n }\n\n /// Returns a borrow of the first type if applicable, otherwise `None`.\n pub fn as_first(&self) -> Option> {\n match self.borrow() {\n ArcUnionBorrow::First(x) => Some(x),\n ArcUnionBorrow::Second(_) => None,\n }\n }\n\n /// Returns a borrow of the second type if applicable, otherwise None.\n pub fn as_second(&self) -> Option> {\n match self.borrow() {\n ArcUnionBorrow::First(_) => None,\n ArcUnionBorrow::Second(x) => Some(x),\n }\n }\n}\n\nimpl Clone for ArcUnion {\n fn clone(&self) -> Self {\n match self.borrow() {\n ArcUnionBorrow::First(x) => ArcUnion::from_first(x.clone_arc()),\n ArcUnionBorrow::Second(x) => ArcUnion::from_second(x.clone_arc()),\n }\n }\n}\n\nimpl Drop for ArcUnion {\n fn drop(&mut self) {\n match self.borrow() {\n ArcUnionBorrow::First(x) => unsafe {\n let _ = Arc::from_raw(&*x);\n },\n ArcUnionBorrow::Second(x) => unsafe {\n let _ = Arc::from_raw(&*x);\n },\n }\n }\n}\n\nimpl fmt::Debug for ArcUnion {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n fmt::Debug::fmt(&self.borrow(), f)\n }\n}\n\n#[cfg(test)]\nmod tests {\n use super::{Arc, ThinArc};\n use std::clone::Clone;\n use std::ops::Drop;\n use std::sync::atomic;\n use std::sync::atomic::Ordering::{Acquire, SeqCst};\n\n #[derive(PartialEq)]\n struct Canary(*mut atomic::AtomicUsize);\n\n impl Drop for Canary {\n fn drop(&mut self) {\n unsafe {\n (*self.0).fetch_add(1, SeqCst);\n }\n }\n }\n\n #[test]\n fn empty_thin() {\n let x = Arc::from_header_and_iter(100u32, std::iter::empty::());\n assert_eq!(x.header, 100);\n assert!(x.slice().is_empty());\n }\n\n #[test]\n fn thin_assert_padding() {\n #[derive(Clone, Default)]\n #[repr(C)]\n struct Padded {\n i: u16,\n }\n\n // The header will have more alignment than `Padded`\n let items = vec![Padded { i: 0xdead }, Padded { i: 0xbeef }];\n let a = ThinArc::from_header_and_iter(0i32, items.into_iter());\n assert_eq!(a.len(), 2);\n assert_eq!(a.slice()[0].i, 0xdead);\n assert_eq!(a.slice()[1].i, 0xbeef);\n }\n\n #[test]\n fn slices_and_thin() {\n let mut canary = atomic::AtomicUsize::new(0);\n let c = Canary(&mut canary as *mut atomic::AtomicUsize);\n let v = vec![5, 6];\n {\n let x = Arc::from_header_and_iter(c, v.into_iter());\n let _ = x.clone();\n let _ = x == x;\n }\n assert_eq!(canary.load(Acquire), 1);\n }\n}\n" }, { "path": "shell.nix", "content": "with import (builtins.fetchTarball {\n url = \"https://github.com/NixOS/nixpkgs/archive/46ae0210ce163b3cba6c7da08840c1d63de9c701.tar.gz\";\n}) {};\nstdenv.mkDerivation rec {\n name = \"style-sync-shell\";\n}\n" }, { "path": "start-rebase.sh", "content": "#!/bin/sh\n# Usage: start-rebase.sh [extra git-rebase(1) arguments ...]\n# Equivalent to git rebase --onto .\nset -eu\n\nnew_base=$1; shift\nfirst_commit=$(git log --pretty=\\%H --grep='Servo initial downstream commit')\nold_base=$first_commit~\n\ngit rebase --onto \"$new_base\" \"$old_base\" \"$@\"\n" }, { "path": "style/Cargo.toml", "content": "[package]\nname = \"stylo\"\nversion.workspace = true\nauthors = [\"The Servo Project Developers\"]\nlicense = \"MPL-2.0\"\nrepository = \"https://github.com/servo/stylo\"\nedition = \"2021\"\ndescription = \"The Stylo CSS engine\"\nreadme = \"../README.md\"\n\nbuild = \"build.rs\"\n\n# https://github.com/rust-lang/cargo/issues/3544\nlinks = \"servo_style_crate\"\n\n[lib]\nname = \"style\"\npath = \"lib.rs\"\ndoctest = false\n\n[features]\ndefault = [\"servo\"]\ngecko = [\n \"bindgen\",\n \"malloc_size_of/gecko\",\n \"mozbuild\",\n \"nsstring\",\n \"regex\",\n \"serde\",\n \"style_traits/gecko\",\n \"toml\",\n \"selectors/to_shmem\",\n \"to_shmem/gecko\",\n]\nservo = [\n \"cssparser/serde\",\n \"encoding_rs\",\n \"malloc_size_of/servo\",\n \"web_atoms\",\n \"mime\",\n \"serde\",\n \"servo_arc/servo\",\n \"stylo_atoms\",\n \"string_cache\",\n \"style_traits/servo\",\n \"url\",\n \"selectors/to_shmem\",\n \"to_shmem/servo\",\n]\ngecko_debug = []\ngecko_refcount_logging = []\nnsstring = []\n\n[dependencies]\napp_units = \"0.7.8\"\narrayvec = \"0.7\"\natomic_refcell = \"0.1\"\nbitflags = \"2\"\nbyteorder = \"1.0\"\ncssparser = \"0.37\"\nderive_more = { version = \"2\", features = [\"add\", \"add_assign\", \"deref\", \"deref_mut\", \"from\"] }\ndom = { workspace = true }\nnew_debug_unreachable = \"1.0\"\nencoding_rs = {version = \"0.8\", optional = true}\neuclid = \"0.22\"\nrustc-hash = \"2.1.1\"\nicu_segmenter = { version = \">= 1.5, <= 2.*\", default-features = false, features = [\"auto\", \"compiled_data\"] }\nindexmap = {version = \"2\", features = [\"std\"]}\nitertools = \"0.14\"\nitoa = \"1.0\"\nlog = \"0.4\"\nmalloc_size_of = { workspace = true }\nmalloc_size_of_derive = \"0.1\"\nweb_atoms = { version = \"0.2.0\", optional = true }\nmime = { version = \"0.3.13\", optional = true }\nnum_cpus = {version = \"1.1.0\"}\nnum-integer = \"0.1\"\nnum-traits = \"0.2\"\nnum-derive = \"0.4\"\nparking_lot = \"0.12\"\nprecomputed-hash = \"0.1.1\"\nrayon = \"1\"\nrayon-core = \"1\"\nselectors = { workspace = true }\nserde = {version = \"1.0\", optional = true, features = [\"derive\"]}\nservo_arc = { workspace = true}\nstylo_atoms = { workspace = true, optional = true}\nsmallbitvec = \"2.3.0\"\nsmallvec = \"1.0\"\nstatic_assertions = \"1.1\"\nstatic_prefs = { workspace = true}\nstring_cache = { version = \"0.9\", optional = true }\nstrum = \"0.28\"\nstrum_macros = \"0.28\"\nstyle_derive = { workspace = true }\nstyle_traits = { workspace = true }\nto_shmem = { workspace = true}\nto_shmem_derive = { workspace = true }\nthin-vec = \"0.2.1\"\nuluru = \"3.0\"\nvoid = \"1.0.2\"\nurl = { version = \"2.5\", optional = true, features = [\"serde\"] }\n\n[build-dependencies]\nlog = { version = \"0.4\", features = [\"std\"] }\nbindgen = {version = \"0.69\", optional = true, default-features = false}\nregex = {version = \"1.0\", optional = true, default-features = false, features = [\"perf\", \"std\"]}\nwalkdir = \"2.1.4\"\ntoml = {version = \"0.5\", optional = true, default-features = false}\nmozbuild = {version = \"0.1\", optional = true}\n" }, { "path": "style/README.md", "content": "servo-style\n===========\n\nStyle system for Servo, using [rust-cssparser](https://github.com/servo/rust-cssparser) for parsing.\n\n * [Documentation](https://book.servo.org/architecture/style.html).\n" }, { "path": "style/applicable_declarations.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! Applicable declarations management.\n\nuse crate::derives::*;\nuse crate::properties::PropertyDeclarationBlock;\nuse crate::rule_tree::{CascadeLevel, RuleCascadeFlags, StyleSource};\nuse crate::shared_lock::Locked;\nuse crate::stylesheets::layer_rule::LayerOrder;\nuse servo_arc::Arc;\nuse smallvec::SmallVec;\n\n/// List of applicable declarations. This is a transient structure that shuttles\n/// declarations between selector matching and inserting into the rule tree, and\n/// therefore we want to avoid heap-allocation where possible.\n///\n/// In measurements on wikipedia, we pretty much never have more than 8 applicable\n/// declarations, so we could consider making this 8 entries instead of 16.\n/// However, it may depend a lot on workload, and stack space is cheap.\npub type ApplicableDeclarationList = SmallVec<[ApplicableDeclarationBlock; 16]>;\n\n/// Blink uses 18 bits to store source order, and does not check overflow [1].\n/// That's a limit that could be reached in realistic webpages, so we use\n/// 24 bits and enforce defined behavior in the overflow case.\n///\n/// Note that right now this restriction could be lifted if wanted (because we\n/// no longer stash the cascade level in the remaining bits), but we keep it in\n/// place in case we come up with a use-case for them, lacking reports of the\n/// current limit being too small.\n///\n/// [1] https://cs.chromium.org/chromium/src/third_party/WebKit/Source/core/css/\n/// RuleSet.h?l=128&rcl=90140ab80b84d0f889abc253410f44ed54ae04f3\nconst SOURCE_ORDER_BITS: usize = 24;\nconst SOURCE_ORDER_MAX: u32 = (1 << SOURCE_ORDER_BITS) - 1;\nconst SOURCE_ORDER_MASK: u32 = SOURCE_ORDER_MAX;\n\n/// The cascade-level+layer order of this declaration.\n#[derive(Clone, Copy, Debug, Eq, Hash, MallocSizeOf, PartialEq)]\npub struct CascadePriority {\n cascade_level: CascadeLevel,\n flags: RuleCascadeFlags,\n layer_order: LayerOrder,\n}\n\nconst_assert_eq!(\n std::mem::size_of::(),\n std::mem::size_of::()\n);\n\nimpl PartialOrd for CascadePriority {\n #[inline]\n fn partial_cmp(&self, other: &Self) -> Option {\n Some(self.cmp(other))\n }\n}\n\nimpl Ord for CascadePriority {\n fn cmp(&self, other: &Self) -> std::cmp::Ordering {\n self.cascade_level.cmp(&other.cascade_level).then_with(|| {\n let ordering = self.layer_order.cmp(&other.layer_order);\n if ordering == std::cmp::Ordering::Equal {\n return ordering;\n }\n // https://drafts.csswg.org/css-cascade-5/#cascade-layering\n //\n // Cascade layers (like declarations) are ordered by order\n // of appearance. When comparing declarations that belong to\n // different layers, then for normal rules the declaration\n // whose cascade layer is last wins, and for important rules\n // the declaration whose cascade layer is first wins.\n //\n // But the style attribute layer for some reason is special.\n if self.cascade_level.is_important()\n && !self.layer_order.is_style_attribute_layer()\n && !other.layer_order.is_style_attribute_layer()\n {\n ordering.reverse()\n } else {\n ordering\n }\n })\n }\n}\n\n/// The kind of revert that we're applying.\n#[derive(Clone, Copy, Debug, Eq, PartialEq)]\npub enum RevertKind {\n /// revert\n Origin,\n /// revert-layer\n Layer,\n /// revert-rule\n Rule,\n}\n\nimpl CascadePriority {\n /// Construct a new CascadePriority for a given (level, order, flags) triple.\n pub fn new(\n cascade_level: CascadeLevel,\n layer_order: LayerOrder,\n flags: RuleCascadeFlags,\n ) -> Self {\n Self {\n cascade_level,\n flags,\n layer_order,\n }\n }\n\n /// Returns the flags.\n #[inline]\n pub fn flags(&self) -> RuleCascadeFlags {\n self.flags\n }\n\n /// Set given flags.\n #[inline]\n pub fn set_flags(&mut self, flags: RuleCascadeFlags) {\n self.flags.insert(flags);\n }\n\n /// Returns the layer order.\n #[inline]\n pub fn layer_order(&self) -> LayerOrder {\n self.layer_order\n }\n\n /// Returns the cascade level.\n #[inline]\n pub fn cascade_level(&self) -> CascadeLevel {\n self.cascade_level\n }\n\n /// Whether this declaration should be allowed if `revert` / `revert-layer` / `revert-rule`\n /// have been specified on a given origin.\n ///\n /// `self` is the priority at which the revert has been specified.\n pub fn allows_when_reverted(&self, other: &Self, kind: RevertKind) -> bool {\n match kind {\n RevertKind::Origin => {\n other.cascade_level.origin().origin() < self.cascade_level.origin().origin()\n },\n RevertKind::Layer => other.unimportant() < self.unimportant(),\n // Any other declaration for the same property we apply in the cascade needs to come\n // from another rule effectively.\n RevertKind::Rule => true,\n }\n }\n\n /// Convert this priority from \"important\" to \"non-important\", if needed.\n pub fn unimportant(&self) -> Self {\n Self {\n cascade_level: self.cascade_level.unimportant(),\n flags: self.flags,\n layer_order: self.layer_order,\n }\n }\n\n /// Convert this priority from \"non-important\" to \"important\", if needed.\n pub fn important(&self) -> Self {\n Self {\n cascade_level: self.cascade_level.important(),\n flags: self.flags,\n layer_order: self.layer_order,\n }\n }\n\n /// The same tree, in author origin, at the root layer.\n pub fn same_tree_author_normal_at_root_layer() -> Self {\n Self::new(\n CascadeLevel::same_tree_author_normal(),\n LayerOrder::root(),\n RuleCascadeFlags::empty(),\n )\n }\n}\n\n/// Proximity to the scope root.\n///\n/// https://drafts.csswg.org/css-cascade-6/#cascade-proximity\n#[derive(Clone, Copy, Debug, Eq, Hash, MallocSizeOf, PartialEq)]\npub struct ScopeProximity(u16);\n\nimpl PartialOrd for ScopeProximity {\n #[inline]\n fn partial_cmp(&self, other: &Self) -> Option {\n Some(self.cmp(other))\n }\n}\n\nimpl Ord for ScopeProximity {\n fn cmp(&self, other: &Self) -> std::cmp::Ordering {\n // Lower proximity to scope root wins\n other.0.cmp(&self.0)\n }\n}\n\n/// Sacrifice the largest possible value for infinity. This makes the comparison\n/// trivial.\nconst PROXIMITY_INFINITY: u16 = u16::MAX;\n\nimpl ScopeProximity {\n /// Construct a new scope proximity.\n pub fn new(proximity: usize) -> Self {\n if cfg!(debug_assertions) && proximity >= PROXIMITY_INFINITY as usize {\n warn!(\"Proximity out of bounds\");\n }\n Self(proximity.clamp(0, (PROXIMITY_INFINITY - 1) as usize) as u16)\n }\n\n /// Create a scope proximity for delcarations outside of any scope root.\n pub fn infinity() -> Self {\n Self(PROXIMITY_INFINITY)\n }\n\n /// If the proximity is finite, get the value.\n pub fn get(&self) -> Option {\n (self.0 != PROXIMITY_INFINITY).then(|| self.0)\n }\n}\n\n/// A property declaration together with its precedence among rules of equal\n/// specificity so that we can sort them.\n///\n/// This represents the declarations in a given declaration block for a given\n/// importance.\n#[derive(Clone, Debug, MallocSizeOf, PartialEq)]\npub struct ApplicableDeclarationBlock {\n /// The style source, either a style rule, or a property declaration block.\n #[ignore_malloc_size_of = \"Arc\"]\n pub source: StyleSource,\n /// Order of appearance in which this rule appears - Set to 0 if not relevant\n /// (e.g. Declaration from `style=\"/*...*/\"`, presentation hints, animations\n /// - See `CascadePriority` instead).\n source_order: u32,\n /// The specificity of the selector.\n pub specificity: u32,\n /// The proximity to the scope root.\n pub scope_proximity: ScopeProximity,\n /// The cascade priority of the rule.\n pub cascade_priority: CascadePriority,\n}\n\nimpl ApplicableDeclarationBlock {\n /// Constructs an applicable declaration block from a given property\n /// declaration block and importance.\n #[inline]\n pub fn from_declarations(\n declarations: Arc>,\n level: CascadeLevel,\n layer_order: LayerOrder,\n ) -> Self {\n ApplicableDeclarationBlock {\n source: StyleSource::from_declarations(declarations),\n source_order: 0,\n specificity: 0,\n scope_proximity: ScopeProximity::infinity(),\n cascade_priority: CascadePriority::new(level, layer_order, RuleCascadeFlags::empty()),\n }\n }\n\n /// Constructs an applicable declaration block from the given components.\n #[inline]\n pub fn new(\n source: StyleSource,\n source_order: u32,\n level: CascadeLevel,\n specificity: u32,\n layer_order: LayerOrder,\n scope_proximity: ScopeProximity,\n flags: RuleCascadeFlags,\n ) -> Self {\n ApplicableDeclarationBlock {\n source,\n source_order: source_order & SOURCE_ORDER_MASK,\n specificity,\n scope_proximity,\n cascade_priority: CascadePriority::new(level, layer_order, flags),\n }\n }\n\n /// Returns the source order of the block.\n #[inline]\n pub fn source_order(&self) -> u32 {\n self.source_order\n }\n\n /// Returns the cascade level of the block.\n #[inline]\n pub fn level(&self) -> CascadeLevel {\n self.cascade_priority.cascade_level()\n }\n\n /// Returns the cascade level of the block.\n #[inline]\n pub fn layer_order(&self) -> LayerOrder {\n self.cascade_priority.layer_order()\n }\n\n /// Returns the scope proximity of the block.\n #[inline]\n pub fn scope_proximity(&self) -> ScopeProximity {\n self.scope_proximity\n }\n\n /// Convenience method to consume self and return the right thing for the\n /// rule tree to iterate over.\n #[inline]\n pub fn for_rule_tree(self) -> (StyleSource, CascadePriority) {\n (self.source, self.cascade_priority)\n }\n\n /// Return the key used to sort applicable declarations.\n #[inline]\n pub fn sort_key(&self) -> (LayerOrder, u32, ScopeProximity, u32) {\n (\n self.layer_order(),\n self.specificity,\n self.scope_proximity(),\n self.source_order(),\n )\n }\n}\n\n// Size of this struct determines sorting and selector-matching performance.\nsize_of_test!(ApplicableDeclarationBlock, 24);\n" }, { "path": "style/author_styles.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! A set of author stylesheets and their computed representation, such as the\n//! ones used for ShadowRoot.\n\nuse crate::derives::*;\nuse crate::invalidation::stylesheets::StylesheetInvalidationSet;\nuse crate::shared_lock::SharedRwLockReadGuard;\nuse crate::stylesheet_set::AuthorStylesheetSet;\nuse crate::stylesheets::StylesheetInDocument;\nuse crate::stylist::CascadeData;\nuse crate::stylist::Stylist;\nuse servo_arc::Arc;\nuse std::sync::LazyLock;\n\n/// A set of author stylesheets and their computed representation, such as the\n/// ones used for ShadowRoot.\n#[derive(MallocSizeOf)]\npub struct GenericAuthorStyles\nwhere\n S: StylesheetInDocument + PartialEq + 'static,\n{\n /// The sheet collection, which holds the sheet pointers, the invalidations,\n /// and all that stuff.\n pub stylesheets: AuthorStylesheetSet,\n /// The actual cascade data computed from the stylesheets.\n #[ignore_malloc_size_of = \"Measured as part of the stylist\"]\n pub data: Arc,\n}\n\npub use self::GenericAuthorStyles as AuthorStyles;\n\nstatic EMPTY_CASCADE_DATA: LazyLock> =\n LazyLock::new(|| Arc::new_leaked(CascadeData::new()));\n\nimpl GenericAuthorStyles\nwhere\n S: StylesheetInDocument + PartialEq + 'static,\n{\n /// Create an empty AuthorStyles.\n #[inline]\n pub fn new() -> Self {\n Self {\n stylesheets: AuthorStylesheetSet::new(),\n data: EMPTY_CASCADE_DATA.clone(),\n }\n }\n\n /// Flush the pending sheet changes, updating `data` as appropriate.\n #[inline]\n pub fn flush(\n &mut self,\n stylist: &mut Stylist,\n guard: &SharedRwLockReadGuard,\n ) -> StylesheetInvalidationSet {\n let (flusher, mut invalidations) = self.stylesheets.flush();\n let result = stylist.rebuild_author_data(\n &self.data,\n flusher.sheets,\n guard,\n &mut invalidations.cascade_data_difference,\n );\n if let Ok(Some(new_data)) = result {\n self.data = new_data;\n }\n invalidations\n }\n}\n" }, { "path": "style/bezier.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! Parametric Bézier curves.\n//!\n//! This is based on `WebCore/platform/graphics/UnitBezier.h` in WebKit.\n\n#![deny(missing_docs)]\n\nuse crate::values::CSSFloat;\n\nconst NEWTON_METHOD_ITERATIONS: u8 = 8;\n\n/// A unit cubic Bézier curve, used for timing functions in CSS transitions and animations.\npub struct Bezier {\n ax: f64,\n bx: f64,\n cx: f64,\n ay: f64,\n by: f64,\n cy: f64,\n}\n\nimpl Bezier {\n /// Calculate the output of a unit cubic Bézier curve from the two middle control points.\n ///\n /// X coordinate is time, Y coordinate is function advancement.\n /// The nominal range for both is 0 to 1.\n ///\n /// The start and end points are always (0, 0) and (1, 1) so that a transition or animation\n /// starts at 0% and ends at 100%.\n pub fn calculate_bezier_output(\n progress: f64,\n epsilon: f64,\n x1: f32,\n y1: f32,\n x2: f32,\n y2: f32,\n ) -> f64 {\n // Check for a linear curve.\n if x1 == y1 && x2 == y2 {\n return progress;\n }\n\n // Ensure that we return 0 or 1 on both edges.\n if progress == 0.0 {\n return 0.0;\n }\n if progress == 1.0 {\n return 1.0;\n }\n\n // For negative values, try to extrapolate with tangent (p1 - p0) or,\n // if p1 is coincident with p0, with (p2 - p0).\n if progress < 0.0 {\n if x1 > 0.0 {\n return progress * y1 as f64 / x1 as f64;\n }\n if y1 == 0.0 && x2 > 0.0 {\n return progress * y2 as f64 / x2 as f64;\n }\n // If we can't calculate a sensible tangent, don't extrapolate at all.\n return 0.0;\n }\n\n // For values greater than 1, try to extrapolate with tangent (p2 - p3) or,\n // if p2 is coincident with p3, with (p1 - p3).\n if progress > 1.0 {\n if x2 < 1.0 {\n return 1.0 + (progress - 1.0) * (y2 as f64 - 1.0) / (x2 as f64 - 1.0);\n }\n if y2 == 1.0 && x1 < 1.0 {\n return 1.0 + (progress - 1.0) * (y1 as f64 - 1.0) / (x1 as f64 - 1.0);\n }\n // If we can't calculate a sensible tangent, don't extrapolate at all.\n return 1.0;\n }\n\n Bezier::new(x1, y1, x2, y2).solve(progress, epsilon)\n }\n\n #[inline]\n fn new(x1: CSSFloat, y1: CSSFloat, x2: CSSFloat, y2: CSSFloat) -> Bezier {\n let cx = 3. * x1 as f64;\n let bx = 3. * (x2 as f64 - x1 as f64) - cx;\n\n let cy = 3. * y1 as f64;\n let by = 3. * (y2 as f64 - y1 as f64) - cy;\n\n Bezier {\n ax: 1.0 - cx - bx,\n bx: bx,\n cx: cx,\n ay: 1.0 - cy - by,\n by: by,\n cy: cy,\n }\n }\n\n #[inline]\n fn sample_curve_x(&self, t: f64) -> f64 {\n // ax * t^3 + bx * t^2 + cx * t\n ((self.ax * t + self.bx) * t + self.cx) * t\n }\n\n #[inline]\n fn sample_curve_y(&self, t: f64) -> f64 {\n ((self.ay * t + self.by) * t + self.cy) * t\n }\n\n #[inline]\n fn sample_curve_derivative_x(&self, t: f64) -> f64 {\n (3.0 * self.ax * t + 2.0 * self.bx) * t + self.cx\n }\n\n #[inline]\n fn solve_curve_x(&self, x: f64, epsilon: f64) -> f64 {\n // Fast path: Use Newton's method.\n let mut t = x;\n for _ in 0..NEWTON_METHOD_ITERATIONS {\n let x2 = self.sample_curve_x(t);\n if x2.approx_eq(x, epsilon) {\n return t;\n }\n let dx = self.sample_curve_derivative_x(t);\n if dx.approx_eq(0.0, 1e-6) {\n break;\n }\n t -= (x2 - x) / dx;\n }\n\n // Slow path: Use bisection.\n let (mut lo, mut hi, mut t) = (0.0, 1.0, x);\n\n if t < lo {\n return lo;\n }\n if t > hi {\n return hi;\n }\n\n while lo < hi {\n let x2 = self.sample_curve_x(t);\n if x2.approx_eq(x, epsilon) {\n return t;\n }\n if x > x2 {\n lo = t\n } else {\n hi = t\n }\n t = (hi - lo) / 2.0 + lo\n }\n\n t\n }\n\n /// Solve the bezier curve for a given `x` and an `epsilon`, that should be\n /// between zero and one.\n #[inline]\n fn solve(&self, x: f64, epsilon: f64) -> f64 {\n self.sample_curve_y(self.solve_curve_x(x, epsilon))\n }\n}\n\ntrait ApproxEq {\n fn approx_eq(self, value: Self, epsilon: Self) -> bool;\n}\n\nimpl ApproxEq for f64 {\n #[inline]\n fn approx_eq(self, value: f64, epsilon: f64) -> bool {\n (self - value).abs() < epsilon\n }\n}\n" }, { "path": "style/bloom.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! The style bloom filter is used as an optimization when matching deep\n//! descendant selectors.\n\n#![deny(missing_docs)]\n\nuse crate::dom::{SendElement, TElement};\nuse crate::LocalName;\nuse atomic_refcell::{AtomicRefCell, AtomicRefMut};\nuse selectors::bloom::BloomFilter;\nuse smallvec::SmallVec;\n\nthread_local! {\n /// Bloom filters are large allocations, so we store them in thread-local storage\n /// such that they can be reused across style traversals. StyleBloom is responsible\n /// for ensuring that the bloom filter is zeroed when it is dropped.\n ///\n /// We intentionally leak this from TLS because we don't have the guarantee\n /// of TLS destructors to run in worker threads.\n ///\n /// Also, leaking it guarantees that we can borrow it indefinitely.\n ///\n /// We could change this once https://github.com/rayon-rs/rayon/issues/688\n /// is fixed, hopefully, which point we'd need to change the filter member below to be an\n /// arc and carry an owning reference around or so.\n static BLOOM_KEY: &'static AtomicRefCell = Box::leak(Default::default());\n}\n\n/// A struct that allows us to fast-reject deep descendant selectors avoiding\n/// selector-matching.\n///\n/// This is implemented using a counting bloom filter, and it's a standard\n/// optimization. See Gecko's `AncestorFilter`, and Blink's and WebKit's\n/// `SelectorFilter`.\n///\n/// The constraints for Servo's style system are a bit different compared to\n/// traditional style systems given Servo does a parallel breadth-first\n/// traversal instead of a sequential depth-first traversal.\n///\n/// This implies that we need to track a bit more state than other browsers to\n/// ensure we're doing the correct thing during the traversal, and being able to\n/// apply this optimization effectively.\n///\n/// Concretely, we have a bloom filter instance per worker thread, and we track\n/// the current DOM depth in order to find a common ancestor when it doesn't\n/// match the previous element we've styled.\n///\n/// This is usually a pretty fast operation (we use to be one level deeper than\n/// the previous one), but in the case of work-stealing, we may needed to push\n/// and pop multiple elements.\n///\n/// See the `insert_parents_recovering`, where most of the magic happens.\n///\n/// Regarding thread-safety, this struct is safe because:\n///\n/// * We clear this after a restyle.\n/// * The DOM shape and attributes (and every other thing we access here) are\n/// immutable during a restyle.\n///\npub struct StyleBloom {\n /// A handle to the bloom filter from the thread upon which this StyleBloom\n /// was created. We use AtomicRefCell so that this is all |Send|, which allows\n /// StyleBloom to live in ThreadLocalStyleContext, which is dropped from the\n /// parent thread.\n filter: AtomicRefMut<'static, BloomFilter>,\n\n /// The stack of elements that this bloom filter contains, along with the\n /// number of hashes pushed for each element.\n elements: SmallVec<[PushedElement; 16]>,\n\n /// Stack of hashes that have been pushed onto this filter.\n pushed_hashes: SmallVec<[u32; 64]>,\n}\n\n/// The very rough benchmarks in the selectors crate show clear()\n/// costing about 25 times more than remove_hash(). We use this to implement\n/// clear() more efficiently when only a small number of hashes have been\n/// pushed.\n///\n/// One subtly to note is that remove_hash() will not touch the value\n/// if the filter overflowed. However, overflow can only occur if we\n/// get 255 collisions on the same hash value, and 25 < 255.\nconst MEMSET_CLEAR_THRESHOLD: usize = 25;\n\nstruct PushedElement {\n /// The element that was pushed.\n element: SendElement,\n\n /// The number of hashes pushed for the element.\n num_hashes: usize,\n}\n\nimpl PushedElement {\n fn new(el: E, num_hashes: usize) -> Self {\n PushedElement {\n element: unsafe { SendElement::new(el) },\n num_hashes,\n }\n }\n}\n\n/// Returns whether the attribute name is excluded from the bloom filter.\n///\n/// We do this for attributes that are very common but not commonly used in\n/// selectors.\n#[inline]\npub fn is_attr_name_excluded_from_filter(name: &LocalName) -> bool {\n *name == local_name!(\"class\") || *name == local_name!(\"id\") || *name == local_name!(\"style\")\n}\n\n/// Gather all relevant hash for fast-reject filters from an element.\npub fn each_relevant_element_hash(element: E, mut f: F)\nwhere\n E: TElement,\n F: FnMut(u32),\n{\n f(element.local_name().get_hash());\n f(element.namespace().get_hash());\n\n if let Some(id) = element.id() {\n f(id.get_hash());\n }\n\n element.each_class(|class| f(class.get_hash()));\n\n element.each_attr_name(|name| {\n if !is_attr_name_excluded_from_filter(name) {\n f(name.get_hash())\n }\n });\n}\n\nimpl Drop for StyleBloom {\n fn drop(&mut self) {\n // Leave the reusable bloom filter in a zeroed state.\n self.clear();\n }\n}\n\nimpl StyleBloom {\n /// Create an empty `StyleBloom`. Because StyleBloom acquires the thread-\n /// local filter buffer, creating multiple live StyleBloom instances at\n /// the same time on the same thread will panic.\n\n // Forced out of line to limit stack frame sizes after extra inlining from\n // https://github.com/rust-lang/rust/pull/43931\n //\n // See https://github.com/servo/servo/pull/18420#issuecomment-328769322\n #[inline(never)]\n pub fn new() -> Self {\n let filter = BLOOM_KEY.with(|b| b.borrow_mut());\n debug_assert!(\n filter.is_zeroed(),\n \"Forgot to zero the bloom filter last time\"\n );\n StyleBloom {\n filter,\n elements: Default::default(),\n pushed_hashes: Default::default(),\n }\n }\n\n /// Return the bloom filter used properly by the `selectors` crate.\n pub fn filter(&self) -> &BloomFilter {\n &*self.filter\n }\n\n /// Push an element to the bloom filter, knowing that it's a child of the\n /// last element parent.\n pub fn push(&mut self, element: E) {\n if cfg!(debug_assertions) {\n if self.elements.is_empty() {\n assert!(element.traversal_parent().is_none());\n }\n }\n self.push_internal(element);\n }\n\n /// Same as `push`, but without asserting, in order to use it from\n /// `rebuild`.\n fn push_internal(&mut self, element: E) {\n let mut count = 0;\n each_relevant_element_hash(element, |hash| {\n count += 1;\n self.filter.insert_hash(hash);\n self.pushed_hashes.push(hash);\n });\n self.elements.push(PushedElement::new(element, count));\n }\n\n /// Pop the last element in the bloom filter and return it.\n #[inline]\n fn pop(&mut self) -> Option {\n let PushedElement {\n element,\n num_hashes,\n } = self.elements.pop()?;\n let popped_element = *element;\n\n // Verify that the pushed hashes match the ones we'd get from the element.\n let mut expected_hashes = vec![];\n if cfg!(debug_assertions) {\n each_relevant_element_hash(popped_element, |hash| expected_hashes.push(hash));\n }\n\n for _ in 0..num_hashes {\n let hash = self.pushed_hashes.pop().unwrap();\n debug_assert_eq!(expected_hashes.pop().unwrap(), hash);\n self.filter.remove_hash(hash);\n }\n\n Some(popped_element)\n }\n\n /// Returns the DOM depth of elements that can be correctly\n /// matched against the bloom filter (that is, the number of\n /// elements in our list).\n pub fn matching_depth(&self) -> usize {\n self.elements.len()\n }\n\n /// Clears the bloom filter.\n pub fn clear(&mut self) {\n self.elements.clear();\n\n if self.pushed_hashes.len() > MEMSET_CLEAR_THRESHOLD {\n self.filter.clear();\n self.pushed_hashes.clear();\n } else {\n for hash in self.pushed_hashes.drain(..) {\n self.filter.remove_hash(hash);\n }\n debug_assert!(self.filter.is_zeroed());\n }\n }\n\n /// Rebuilds the bloom filter up to the parent of the given element.\n pub fn rebuild(&mut self, mut element: E) {\n self.clear();\n\n let mut parents_to_insert = SmallVec::<[E; 16]>::new();\n while let Some(parent) = element.traversal_parent() {\n parents_to_insert.push(parent);\n element = parent;\n }\n\n for parent in parents_to_insert.drain(..).rev() {\n self.push(parent);\n }\n }\n\n /// In debug builds, asserts that all the parents of `element` are in the\n /// bloom filter.\n ///\n /// Goes away in release builds.\n pub fn assert_complete(&self, mut element: E) {\n if cfg!(debug_assertions) {\n let mut checked = 0;\n while let Some(parent) = element.traversal_parent() {\n assert_eq!(\n parent,\n *(self.elements[self.elements.len() - 1 - checked].element)\n );\n element = parent;\n checked += 1;\n }\n assert_eq!(checked, self.elements.len());\n }\n }\n\n /// Get the element that represents the chain of things inserted\n /// into the filter right now. That chain is the given element\n /// (if any) and its ancestors.\n #[inline]\n pub fn current_parent(&self) -> Option {\n self.elements.last().map(|ref el| *el.element)\n }\n\n /// Insert the parents of an element in the bloom filter, trying to recover\n /// the filter if the last element inserted doesn't match.\n ///\n /// Gets the element depth in the dom, to make it efficient, or if not\n /// provided always rebuilds the filter from scratch.\n ///\n /// Returns the new bloom filter depth, that the traversal code is\n /// responsible to keep around if it wants to get an effective filter.\n pub fn insert_parents_recovering(&mut self, element: E, element_depth: usize) {\n // Easy case, we're in a different restyle, or we're empty.\n if self.elements.is_empty() {\n self.rebuild(element);\n return;\n }\n\n let traversal_parent = match element.traversal_parent() {\n Some(parent) => parent,\n None => {\n // Yay, another easy case.\n self.clear();\n return;\n },\n };\n\n if self.current_parent() == Some(traversal_parent) {\n // Ta da, cache hit, we're all done.\n return;\n }\n\n if element_depth == 0 {\n self.clear();\n return;\n }\n\n // We should've early exited above.\n debug_assert!(\n element_depth != 0,\n \"We should have already cleared the bloom filter\"\n );\n debug_assert!(!self.elements.is_empty(), \"How! We should've just rebuilt!\");\n\n // Now the fun begins: We have the depth of the dom and the depth of the\n // last element inserted in the filter, let's try to find a common\n // parent.\n //\n // The current depth, that is, the depth of the last element inserted in\n // the bloom filter, is the number of elements _minus one_, that is: if\n // there's one element, it must be the root -> depth zero.\n let mut current_depth = self.elements.len() - 1;\n\n // If the filter represents an element too deep in the dom, we need to\n // pop ancestors.\n while current_depth > element_depth - 1 {\n self.pop().expect(\"Emilio is bad at math\");\n current_depth -= 1;\n }\n\n // Now let's try to find a common parent in the bloom filter chain,\n // starting with traversal_parent.\n let mut common_parent = traversal_parent;\n let mut common_parent_depth = element_depth - 1;\n\n // Let's collect the parents we are going to need to insert once we've\n // found the common one.\n let mut parents_to_insert = SmallVec::<[E; 16]>::new();\n\n // If the bloom filter still doesn't have enough elements, the common\n // parent is up in the dom.\n while common_parent_depth > current_depth {\n // TODO(emilio): Seems like we could insert parents here, then\n // reverse the slice.\n parents_to_insert.push(common_parent);\n common_parent = common_parent.traversal_parent().expect(\"We were lied to\");\n common_parent_depth -= 1;\n }\n\n // Now the two depths are the same.\n debug_assert_eq!(common_parent_depth, current_depth);\n\n // Happy case: The parents match, we only need to push the ancestors\n // we've collected and we'll never enter in this loop.\n //\n // Not-so-happy case: Parent's don't match, so we need to keep going up\n // until we find a common ancestor.\n //\n // Gecko currently models native anonymous content that conceptually\n // hangs off the document (such as scrollbars) as a separate subtree\n // from the document root.\n //\n // Thus it's possible with Gecko that we do not find any common\n // ancestor.\n while *(self.elements.last().unwrap().element) != common_parent {\n parents_to_insert.push(common_parent);\n self.pop().unwrap();\n common_parent = match common_parent.traversal_parent() {\n Some(parent) => parent,\n None => {\n debug_assert!(self.elements.is_empty());\n if cfg!(feature = \"gecko\") {\n break;\n } else {\n panic!(\"should have found a common ancestor\");\n }\n },\n }\n }\n\n // Now the parents match, so insert the stack of elements we have been\n // collecting so far.\n for parent in parents_to_insert.drain(..).rev() {\n self.push(parent);\n }\n\n debug_assert_eq!(self.elements.len(), element_depth);\n\n // We're done! Easy.\n }\n}\n" }, { "path": "style/build.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\nuse std::env;\nuse std::path::Path;\nuse std::process::{exit, Command};\nuse std::sync::LazyLock;\nuse walkdir::WalkDir;\n\n#[cfg(feature = \"gecko\")]\nmod build_gecko;\n\n#[cfg(not(feature = \"gecko\"))]\nmod build_gecko {\n pub fn generate() {}\n}\n\npub static PYTHON: LazyLock = LazyLock::new(|| {\n env::var(\"PYTHON3\").ok().unwrap_or_else(|| {\n let candidates = if cfg!(windows) {\n [\"python.exe\"]\n } else {\n [\"python3\"]\n };\n for &name in &candidates {\n if Command::new(name)\n .arg(\"--version\")\n .output()\n .ok()\n .map_or(false, |out| out.status.success())\n {\n return name.to_owned();\n }\n }\n panic!(\n \"Can't find python (tried {})! Try fixing PATH or setting the PYTHON3 env var\",\n candidates.join(\", \")\n )\n })\n});\n\nfn generate_properties(engine: &str) {\n for entry in WalkDir::new(\"properties\") {\n let entry = entry.unwrap();\n match entry.path().extension().and_then(|e| e.to_str()) {\n Some(\"mako\") | Some(\"rs\") | Some(\"py\") | Some(\"zip\") | Some(\"toml\") => {\n println!(\"cargo:rerun-if-changed={}\", entry.path().display());\n },\n _ => {},\n }\n }\n\n let script = Path::new(&env::var_os(\"CARGO_MANIFEST_DIR\").unwrap())\n .join(\"properties\")\n .join(\"build.py\");\n\n let status = Command::new(&*PYTHON)\n // `cargo publish` isn't happy with the `__pycache__` files that are created\n // when we run the property generator.\n //\n // TODO(mrobinson): Is this happening because of how we run this script? It\n // would be better to ensure are just placed in the output directory.\n .env(\"PYTHONDONTWRITEBYTECODE\", \"1\")\n .arg(&script)\n .arg(engine)\n .arg(\"style-crate\")\n .status()\n .unwrap();\n if !status.success() {\n exit(1)\n }\n}\n\nfn main() {\n let gecko = cfg!(feature = \"gecko\");\n let servo = cfg!(feature = \"servo\");\n let engine = match (gecko, servo) {\n (true, false) => \"gecko\",\n (false, true) => \"servo\",\n _ => panic!(\n \"\\n\\n\\\n The style crate requires enabling one of its 'servo' or 'gecko' feature flags. \\\n \\n\\n\"\n ),\n };\n println!(\"cargo:rerun-if-changed=build.rs\");\n println!(\"cargo:out_dir={}\", env::var(\"OUT_DIR\").unwrap());\n generate_properties(engine);\n build_gecko::generate();\n}\n" }, { "path": "style/build_gecko.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\nuse super::PYTHON;\nuse bindgen::{Builder, CodegenConfig};\nuse regex::Regex;\nuse std::cmp;\nuse std::collections::HashSet;\nuse std::env;\nuse std::fs::{self, File};\nuse std::io::{Read, Write};\nuse std::path::{Path, PathBuf};\nuse std::process::{exit, Command};\nuse std::slice;\nuse std::sync::LazyLock;\nuse std::sync::Mutex;\nuse std::time::SystemTime;\nuse toml;\nuse toml::value::Table;\n\nstatic OUTDIR_PATH: LazyLock =\n LazyLock::new(|| PathBuf::from(env::var_os(\"OUT_DIR\").unwrap()).join(\"gecko\"));\n\nconst STRUCTS_FILE: &'static str = \"structs.rs\";\n\nfn read_config(path: &PathBuf) -> Table {\n println!(\"cargo:rerun-if-changed={}\", path.to_str().unwrap());\n update_last_modified(&path);\n\n let mut contents = String::new();\n File::open(path)\n .expect(\"Failed to open config file\")\n .read_to_string(&mut contents)\n .expect(\"Failed to read config file\");\n match toml::from_str::(&contents) {\n Ok(result) => result,\n Err(e) => panic!(\"Failed to parse config file: {}\", e),\n }\n}\n\nstatic CONFIG: LazyLock
= LazyLock::new(|| {\n // Load Gecko's binding generator config from the source tree.\n let path = mozbuild::TOPSRCDIR.join(\"layout/style/ServoBindings.toml\");\n read_config(&path)\n});\nstatic BINDGEN_FLAGS: LazyLock> = LazyLock::new(|| {\n mozbuild::config::BINDGEN_SYSTEM_FLAGS\n .iter()\n .chain(&mozbuild::config::NSPR_CFLAGS)\n .chain(&mozbuild::config::MOZ_PIXMAN_CFLAGS)\n .chain(&mozbuild::config::MOZ_ICU_CFLAGS)\n .map(|s| s.to_string())\n .collect()\n});\nstatic INCLUDE_RE: LazyLock = LazyLock::new(|| Regex::new(r#\"#include\\s*\"(.+?)\"\"#).unwrap());\nstatic DISTDIR_PATH: LazyLock = LazyLock::new(|| mozbuild::TOPOBJDIR.join(\"dist\"));\nstatic SEARCH_PATHS: LazyLock> = LazyLock::new(|| {\n vec![\n DISTDIR_PATH.join(\"include\"),\n DISTDIR_PATH.join(\"include/nspr\"),\n ]\n});\nstatic ADDED_PATHS: LazyLock>> =\n LazyLock::new(|| Mutex::new(HashSet::new()));\nstatic LAST_MODIFIED: LazyLock> = LazyLock::new(|| {\n Mutex::new(\n get_modified_time(&env::current_exe().unwrap())\n .expect(\"Failed to get modified time of executable\"),\n )\n});\n\nfn get_modified_time(file: &Path) -> Option {\n file.metadata().and_then(|m| m.modified()).ok()\n}\n\nfn update_last_modified(file: &Path) {\n let modified = get_modified_time(file).expect(\"Couldn't get file modification time\");\n let mut last_modified = LAST_MODIFIED.lock().unwrap();\n *last_modified = cmp::max(modified, *last_modified);\n}\n\nfn search_include(name: &str) -> Option {\n for path in SEARCH_PATHS.iter() {\n let file = path.join(name);\n if file.is_file() {\n update_last_modified(&file);\n return Some(file);\n }\n }\n None\n}\n\nfn add_headers_recursively(path: PathBuf, added_paths: &mut HashSet) {\n if added_paths.contains(&path) {\n return;\n }\n let mut file = File::open(&path).unwrap();\n let mut content = String::new();\n file.read_to_string(&mut content).unwrap();\n added_paths.insert(path);\n // Find all includes and add them recursively\n for cap in INCLUDE_RE.captures_iter(&content) {\n if let Some(path) = search_include(cap.get(1).unwrap().as_str()) {\n add_headers_recursively(path, added_paths);\n }\n }\n}\n\nfn add_include(name: &str) -> String {\n let mut added_paths = ADDED_PATHS.lock().unwrap();\n let file = match search_include(name) {\n Some(file) => file,\n None => panic!(\"Include not found: {}\", name),\n };\n let result = String::from(file.to_str().unwrap());\n add_headers_recursively(file, &mut *added_paths);\n result\n}\n\ntrait BuilderExt {\n fn get_initial_builder() -> Builder;\n fn include>(self, file: T) -> Builder;\n}\n\nimpl BuilderExt for Builder {\n fn get_initial_builder() -> Builder {\n // Disable rust unions, because we replace some types inside of\n // them.\n let mut builder = Builder::default()\n .size_t_is_usize(true)\n .disable_untagged_union();\n\n let rustfmt_path = env::var_os(\"RUSTFMT\")\n .filter(|p| !p.is_empty())\n .map(PathBuf::from);\n if let Some(path) = rustfmt_path {\n builder = builder.with_rustfmt(path);\n }\n\n for dir in SEARCH_PATHS.iter() {\n builder = builder.clang_arg(\"-I\").clang_arg(dir.to_str().unwrap());\n }\n\n builder = builder.include(add_include(\"mozilla-config.h\"));\n\n if env::var(\"CARGO_FEATURE_GECKO_DEBUG\").is_ok() {\n builder = builder.clang_arg(\"-DDEBUG=1\").clang_arg(\"-DJS_DEBUG=1\");\n }\n\n for item in &*BINDGEN_FLAGS {\n builder = builder.clang_arg(item);\n }\n\n builder\n }\n fn include>(self, file: T) -> Builder {\n self.clang_arg(\"-include\").clang_arg(file)\n }\n}\n\nstruct Fixup {\n pat: String,\n rep: String,\n}\n\nfn write_binding_file(builder: Builder, file: &str, fixups: &[Fixup]) {\n let out_file = OUTDIR_PATH.join(file);\n if let Some(modified) = get_modified_time(&out_file) {\n // Don't generate the file if nothing it depends on was modified.\n let last_modified = LAST_MODIFIED.lock().unwrap();\n if *last_modified <= modified {\n return;\n }\n }\n let command_line_opts = builder.command_line_flags();\n let result = builder.generate();\n let mut result = match result {\n Ok(bindings) => bindings.to_string(),\n Err(_) => {\n panic!(\n \"Failed to generate bindings, flags: {:?}\",\n command_line_opts\n );\n },\n };\n\n for fixup in fixups.iter() {\n result = Regex::new(&fixup.pat)\n .unwrap()\n .replace_all(&result, &*fixup.rep)\n .into_owned()\n .into();\n }\n let bytes = result.into_bytes();\n File::create(&out_file)\n .unwrap()\n .write_all(&bytes)\n .expect(\"Unable to write output\");\n}\n\nstruct BuilderWithConfig<'a> {\n builder: Builder,\n config: &'a Table,\n used_keys: HashSet<&'static str>,\n}\nimpl<'a> BuilderWithConfig<'a> {\n fn new(builder: Builder, config: &'a Table) -> Self {\n BuilderWithConfig {\n builder,\n config,\n used_keys: HashSet::new(),\n }\n }\n\n fn handle_list(self, key: &'static str, func: F) -> BuilderWithConfig<'a>\n where\n F: FnOnce(Builder, slice::Iter<'a, toml::Value>) -> Builder,\n {\n let mut builder = self.builder;\n let config = self.config;\n let mut used_keys = self.used_keys;\n if let Some(list) = config.get(key) {\n used_keys.insert(key);\n builder = func(builder, list.as_array().unwrap().as_slice().iter());\n }\n BuilderWithConfig {\n builder,\n config,\n used_keys,\n }\n }\n fn handle_items(self, key: &'static str, mut func: F) -> BuilderWithConfig<'a>\n where\n F: FnMut(Builder, &'a toml::Value) -> Builder,\n {\n self.handle_list(key, |b, iter| iter.fold(b, |b, item| func(b, item)))\n }\n fn handle_str_items(self, key: &'static str, mut func: F) -> BuilderWithConfig<'a>\n where\n F: FnMut(Builder, &'a str) -> Builder,\n {\n self.handle_items(key, |b, item| func(b, item.as_str().unwrap()))\n }\n fn handle_table_items(self, key: &'static str, mut func: F) -> BuilderWithConfig<'a>\n where\n F: FnMut(Builder, &'a Table) -> Builder,\n {\n self.handle_items(key, |b, item| func(b, item.as_table().unwrap()))\n }\n fn handle_common(self, fixups: &mut Vec) -> BuilderWithConfig<'a> {\n self.handle_str_items(\"headers\", |b, item| b.header(add_include(item)))\n .handle_str_items(\"raw-lines\", |b, item| b.raw_line(item))\n .handle_str_items(\"hide-types\", |b, item| b.blocklist_type(item))\n .handle_table_items(\"fixups\", |builder, item| {\n fixups.push(Fixup {\n pat: item[\"pat\"].as_str().unwrap().into(),\n rep: item[\"rep\"].as_str().unwrap().into(),\n });\n builder\n })\n }\n\n fn get_builder(self) -> Builder {\n for key in self.config.keys() {\n if !self.used_keys.contains(key.as_str()) {\n panic!(\"Unknown key: {}\", key);\n }\n }\n self.builder\n }\n}\n\nfn generate_structs() {\n let builder = Builder::get_initial_builder()\n .enable_cxx_namespaces()\n .with_codegen_config(CodegenConfig::TYPES | CodegenConfig::VARS | CodegenConfig::FUNCTIONS);\n let mut fixups = vec![];\n let builder = BuilderWithConfig::new(builder, CONFIG[\"structs\"].as_table().unwrap())\n .handle_common(&mut fixups)\n .handle_str_items(\"allowlist-functions\", |b, item| b.allowlist_function(item))\n .handle_str_items(\"bitfield-enums\", |b, item| b.bitfield_enum(item))\n .handle_str_items(\"rusty-enums\", |b, item| b.rustified_enum(item))\n .handle_str_items(\"allowlist-vars\", |b, item| b.allowlist_var(item))\n .handle_str_items(\"allowlist-types\", |b, item| b.allowlist_type(item))\n .handle_str_items(\"opaque-types\", |b, item| b.opaque_type(item))\n .handle_table_items(\"cbindgen-types\", |b, item| {\n let gecko = item[\"gecko\"].as_str().unwrap();\n let servo = item[\"servo\"].as_str().unwrap();\n b.blocklist_type(format!(\"mozilla::{}\", gecko))\n .module_raw_line(\"root::mozilla\", format!(\"pub use {} as {};\", servo, gecko))\n })\n .handle_table_items(\"mapped-generic-types\", |builder, item| {\n let generic = item[\"generic\"].as_bool().unwrap();\n let gecko = item[\"gecko\"].as_str().unwrap();\n let servo = item[\"servo\"].as_str().unwrap();\n let gecko_name = gecko.rsplit(\"::\").next().unwrap();\n let gecko = gecko\n .split(\"::\")\n .map(|s| format!(\"\\\\s*{}\\\\s*\", s))\n .collect::>()\n .join(\"::\");\n\n fixups.push(Fixup {\n pat: format!(\"\\\\broot\\\\s*::\\\\s*{}\\\\b\", gecko),\n rep: format!(\"crate::gecko_bindings::structs::{}\", gecko_name),\n });\n builder.blocklist_type(gecko).raw_line(format!(\n \"pub type {0}{2} = {1}{2};\",\n gecko_name,\n servo,\n if generic { \"\" } else { \"\" }\n ))\n })\n .get_builder();\n write_binding_file(builder, STRUCTS_FILE, &fixups);\n}\n\nfn setup_logging() -> bool {\n struct BuildLogger {\n file: Option>,\n filter: String,\n }\n\n impl log::Log for BuildLogger {\n fn enabled(&self, meta: &log::Metadata) -> bool {\n self.file.is_some() && meta.target().contains(&self.filter)\n }\n\n fn log(&self, record: &log::Record) {\n if !self.enabled(record.metadata()) {\n return;\n }\n\n let mut file = self.file.as_ref().unwrap().lock().unwrap();\n let _ = writeln!(\n file,\n \"{} - {} - {} @ {}:{}\",\n record.level(),\n record.target(),\n record.args(),\n record.file().unwrap_or(\"\"),\n record.line().unwrap_or(0)\n );\n }\n\n fn flush(&self) {\n if let Some(ref file) = self.file {\n file.lock().unwrap().flush().unwrap();\n }\n }\n }\n\n if let Some(path) = env::var_os(\"STYLO_BUILD_LOG\") {\n log::set_max_level(log::LevelFilter::Debug);\n log::set_boxed_logger(Box::new(BuildLogger {\n file: fs::File::create(path).ok().map(Mutex::new),\n filter: env::var(\"STYLO_BUILD_FILTER\")\n .ok()\n .unwrap_or_else(|| \"bindgen\".to_owned()),\n }))\n .expect(\"Failed to set logger.\");\n\n true\n } else {\n false\n }\n}\n\nfn generate_atoms() {\n let script = PathBuf::from(env::var_os(\"CARGO_MANIFEST_DIR\").unwrap())\n .join(\"gecko\")\n .join(\"regen_atoms.py\");\n println!(\"cargo:rerun-if-changed={}\", script.display());\n let status = Command::new(&*PYTHON)\n .arg(&script)\n .arg(DISTDIR_PATH.as_os_str())\n .arg(OUTDIR_PATH.as_os_str())\n .status()\n .unwrap();\n if !status.success() {\n exit(1);\n }\n}\n\npub fn generate() {\n println!(\"cargo:rerun-if-changed=build_gecko.rs\");\n fs::create_dir_all(&*OUTDIR_PATH).unwrap();\n setup_logging();\n generate_structs();\n generate_atoms();\n\n for path in ADDED_PATHS.lock().unwrap().iter() {\n println!(\"cargo:rerun-if-changed={}\", path.to_str().unwrap());\n }\n}\n" }, { "path": "style/color/color_function.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! Output of parsing a color function, e.g. rgb(..), hsl(..), color(..)\n\nuse std::fmt::Write;\n\nuse super::{\n component::ColorComponent,\n convert::normalize_hue,\n parsing::{NumberOrAngleComponent, NumberOrPercentageComponent},\n AbsoluteColor, ColorFlags, ColorSpace,\n};\nuse crate::derives::*;\nuse crate::values::{\n computed::color::Color as ComputedColor, generics::Optional, normalize,\n specified::color::Color as SpecifiedColor,\n};\nuse cssparser::color::{clamp_floor_256_f32, OPAQUE};\n\n/// Represents a specified color function.\n#[derive(Clone, Debug, MallocSizeOf, PartialEq, ToAnimatedValue, ToShmem)]\n#[repr(u8)]\npub enum ColorFunction {\n /// \n Rgb(\n Optional, // origin\n ColorComponent, // red\n ColorComponent, // green\n ColorComponent, // blue\n ColorComponent, // alpha\n ),\n /// \n Hsl(\n Optional, // origin\n ColorComponent, // hue\n ColorComponent, // saturation\n ColorComponent, // lightness\n ColorComponent, // alpha\n ),\n /// \n Hwb(\n Optional, // origin\n ColorComponent, // hue\n ColorComponent, // whiteness\n ColorComponent, // blackness\n ColorComponent, // alpha\n ),\n /// \n Lab(\n Optional, // origin\n ColorComponent, // lightness\n ColorComponent, // a\n ColorComponent, // b\n ColorComponent, // alpha\n ),\n /// \n Lch(\n Optional, // origin\n ColorComponent, // lightness\n ColorComponent, // chroma\n ColorComponent, // hue\n ColorComponent, // alpha\n ),\n /// \n Oklab(\n Optional, // origin\n ColorComponent, // lightness\n ColorComponent, // a\n ColorComponent, // b\n ColorComponent, // alpha\n ),\n /// \n Oklch(\n Optional, // origin\n ColorComponent, // lightness\n ColorComponent, // chroma\n ColorComponent, // hue\n ColorComponent, // alpha\n ),\n /// \n Color(\n Optional, // origin\n ColorComponent, // red / x\n ColorComponent, // green / y\n ColorComponent, // blue / z\n ColorComponent, // alpha\n ColorSpace,\n ),\n}\n\nimpl ColorFunction {\n /// Try to resolve into a valid absolute color.\n pub fn resolve_to_absolute(&self) -> Result {\n macro_rules! alpha {\n ($alpha:expr, $origin_color:expr) => {{\n $alpha\n .resolve($origin_color)?\n .map(|value| normalize(value.to_number(1.0)).clamp(0.0, OPAQUE))\n }};\n }\n\n Ok(match self {\n ColorFunction::Rgb(origin_color, r, g, b, alpha) => {\n // Use `color(srgb ...)` to serialize `rgb(...)` if an origin color is available;\n // this is the only reason for now.\n let use_color_syntax = origin_color.is_some();\n\n if use_color_syntax {\n let origin_color = origin_color.as_ref().map(|origin| {\n let origin = origin.to_color_space(ColorSpace::Srgb);\n // Because rgb(..) syntax have components in range [0..255), we have to\n // map them.\n // NOTE: The IS_LEGACY_SRGB flag is not added back to the color, because\n // we're going to return the modern color(srgb ..) syntax.\n AbsoluteColor::new(\n ColorSpace::Srgb,\n origin.c0().map(|v| v * 255.0),\n origin.c1().map(|v| v * 255.0),\n origin.c2().map(|v| v * 255.0),\n origin.alpha(),\n )\n });\n\n // We have to map all the components back to [0..1) range after all the\n // calculations.\n AbsoluteColor::new(\n ColorSpace::Srgb,\n r.resolve(origin_color.as_ref())?\n .map(|c| c.to_number(255.0) / 255.0),\n g.resolve(origin_color.as_ref())?\n .map(|c| c.to_number(255.0) / 255.0),\n b.resolve(origin_color.as_ref())?\n .map(|c| c.to_number(255.0) / 255.0),\n alpha!(alpha, origin_color.as_ref()),\n )\n } else {\n #[inline]\n fn resolve(\n component: &ColorComponent,\n origin_color: Option<&AbsoluteColor>,\n ) -> Result {\n Ok(clamp_floor_256_f32(\n component\n .resolve(origin_color)?\n .map_or(0.0, |value| value.to_number(u8::MAX as f32)),\n ))\n }\n\n let origin_color = origin_color.as_ref().map(|o| o.into_srgb_legacy());\n\n AbsoluteColor::srgb_legacy(\n resolve(r, origin_color.as_ref())?,\n resolve(g, origin_color.as_ref())?,\n resolve(b, origin_color.as_ref())?,\n alpha!(alpha, origin_color.as_ref()).unwrap_or(0.0),\n )\n }\n },\n ColorFunction::Hsl(origin_color, h, s, l, alpha) => {\n // Percent reference range for S and L: 0% = 0.0, 100% = 100.0\n const LIGHTNESS_RANGE: f32 = 100.0;\n const SATURATION_RANGE: f32 = 100.0;\n\n // If the origin color:\n // - was *NOT* specified, then we stick with the old way of serializing the\n // value to rgb(..).\n // - was specified, we don't use the rgb(..) syntax, because we should allow the\n // color to be out of gamut and not clamp.\n let use_rgb_sytax = origin_color.is_none();\n\n let origin_color = origin_color\n .as_ref()\n .map(|o| o.to_color_space(ColorSpace::Hsl));\n\n let mut result = AbsoluteColor::new(\n ColorSpace::Hsl,\n h.resolve(origin_color.as_ref())?\n .map(|angle| normalize_hue(angle.degrees())),\n s.resolve(origin_color.as_ref())?.map(|s| {\n if use_rgb_sytax {\n s.to_number(SATURATION_RANGE).clamp(0.0, SATURATION_RANGE)\n } else {\n s.to_number(SATURATION_RANGE)\n }\n }),\n l.resolve(origin_color.as_ref())?.map(|l| {\n if use_rgb_sytax {\n l.to_number(LIGHTNESS_RANGE).clamp(0.0, LIGHTNESS_RANGE)\n } else {\n l.to_number(LIGHTNESS_RANGE)\n }\n }),\n alpha!(alpha, origin_color.as_ref()),\n );\n\n if use_rgb_sytax {\n result.flags.insert(ColorFlags::IS_LEGACY_SRGB);\n }\n\n result\n },\n ColorFunction::Hwb(origin_color, h, w, b, alpha) => {\n // If the origin color:\n // - was *NOT* specified, then we stick with the old way of serializing the\n // value to rgb(..).\n // - was specified, we don't use the rgb(..) syntax, because we should allow the\n // color to be out of gamut and not clamp.\n let use_rgb_sytax = origin_color.is_none();\n\n // Percent reference range for W and B: 0% = 0.0, 100% = 100.0\n const WHITENESS_RANGE: f32 = 100.0;\n const BLACKNESS_RANGE: f32 = 100.0;\n\n let origin_color = origin_color\n .as_ref()\n .map(|o| o.to_color_space(ColorSpace::Hwb));\n\n let mut result = AbsoluteColor::new(\n ColorSpace::Hwb,\n h.resolve(origin_color.as_ref())?\n .map(|angle| normalize_hue(angle.degrees())),\n w.resolve(origin_color.as_ref())?.map(|w| {\n if use_rgb_sytax {\n w.to_number(WHITENESS_RANGE).clamp(0.0, WHITENESS_RANGE)\n } else {\n w.to_number(WHITENESS_RANGE)\n }\n }),\n b.resolve(origin_color.as_ref())?.map(|b| {\n if use_rgb_sytax {\n b.to_number(BLACKNESS_RANGE).clamp(0.0, BLACKNESS_RANGE)\n } else {\n b.to_number(BLACKNESS_RANGE)\n }\n }),\n alpha!(alpha, origin_color.as_ref()),\n );\n\n if use_rgb_sytax {\n result.flags.insert(ColorFlags::IS_LEGACY_SRGB);\n }\n\n result\n },\n ColorFunction::Lab(origin_color, l, a, b, alpha) => {\n // for L: 0% = 0.0, 100% = 100.0\n // for a and b: -100% = -125, 100% = 125\n const LIGHTNESS_RANGE: f32 = 100.0;\n const A_B_RANGE: f32 = 125.0;\n\n let origin_color = origin_color\n .as_ref()\n .map(|o| o.to_color_space(ColorSpace::Lab));\n\n AbsoluteColor::new(\n ColorSpace::Lab,\n l.resolve(origin_color.as_ref())?\n .map(|l| l.to_number(LIGHTNESS_RANGE)),\n a.resolve(origin_color.as_ref())?\n .map(|a| a.to_number(A_B_RANGE)),\n b.resolve(origin_color.as_ref())?\n .map(|b| b.to_number(A_B_RANGE)),\n alpha!(alpha, origin_color.as_ref()),\n )\n },\n ColorFunction::Lch(origin_color, l, c, h, alpha) => {\n // for L: 0% = 0.0, 100% = 100.0\n // for C: 0% = 0, 100% = 150\n const LIGHTNESS_RANGE: f32 = 100.0;\n const CHROMA_RANGE: f32 = 150.0;\n\n let origin_color = origin_color\n .as_ref()\n .map(|o| o.to_color_space(ColorSpace::Lch));\n\n AbsoluteColor::new(\n ColorSpace::Lch,\n l.resolve(origin_color.as_ref())?\n .map(|l| l.to_number(LIGHTNESS_RANGE)),\n c.resolve(origin_color.as_ref())?\n .map(|c| c.to_number(CHROMA_RANGE)),\n h.resolve(origin_color.as_ref())?\n .map(|angle| normalize_hue(angle.degrees())),\n alpha!(alpha, origin_color.as_ref()),\n )\n },\n ColorFunction::Oklab(origin_color, l, a, b, alpha) => {\n // for L: 0% = 0.0, 100% = 1.0\n // for a and b: -100% = -0.4, 100% = 0.4\n const LIGHTNESS_RANGE: f32 = 1.0;\n const A_B_RANGE: f32 = 0.4;\n\n let origin_color = origin_color\n .as_ref()\n .map(|o| o.to_color_space(ColorSpace::Oklab));\n\n AbsoluteColor::new(\n ColorSpace::Oklab,\n l.resolve(origin_color.as_ref())?\n .map(|l| l.to_number(LIGHTNESS_RANGE)),\n a.resolve(origin_color.as_ref())?\n .map(|a| a.to_number(A_B_RANGE)),\n b.resolve(origin_color.as_ref())?\n .map(|b| b.to_number(A_B_RANGE)),\n alpha!(alpha, origin_color.as_ref()),\n )\n },\n ColorFunction::Oklch(origin_color, l, c, h, alpha) => {\n // for L: 0% = 0.0, 100% = 1.0\n // for C: 0% = 0.0 100% = 0.4\n const LIGHTNESS_RANGE: f32 = 1.0;\n const CHROMA_RANGE: f32 = 0.4;\n\n let origin_color = origin_color\n .as_ref()\n .map(|o| o.to_color_space(ColorSpace::Oklch));\n\n AbsoluteColor::new(\n ColorSpace::Oklch,\n l.resolve(origin_color.as_ref())?\n .map(|l| l.to_number(LIGHTNESS_RANGE)),\n c.resolve(origin_color.as_ref())?\n .map(|c| c.to_number(CHROMA_RANGE)),\n h.resolve(origin_color.as_ref())?\n .map(|angle| normalize_hue(angle.degrees())),\n alpha!(alpha, origin_color.as_ref()),\n )\n },\n ColorFunction::Color(origin_color, r, g, b, alpha, color_space) => {\n let origin_color = origin_color.as_ref().map(|o| {\n let mut result = o.to_color_space(*color_space);\n\n // If the origin color was a `rgb(..)` function, we should\n // make sure it doesn't have the legacy flag any more so\n // that it is recognized as a `color(srgb ..)` function.\n result.flags.set(ColorFlags::IS_LEGACY_SRGB, false);\n\n result\n });\n\n AbsoluteColor::new(\n *color_space,\n r.resolve(origin_color.as_ref())?.map(|c| c.to_number(1.0)),\n g.resolve(origin_color.as_ref())?.map(|c| c.to_number(1.0)),\n b.resolve(origin_color.as_ref())?.map(|c| c.to_number(1.0)),\n alpha!(alpha, origin_color.as_ref()),\n )\n },\n })\n }\n}\n\nimpl ColorFunction {\n /// Return true if the color funciton has an origin color specified.\n pub fn has_origin_color(&self) -> bool {\n match self {\n Self::Rgb(origin_color, ..)\n | Self::Hsl(origin_color, ..)\n | Self::Hwb(origin_color, ..)\n | Self::Lab(origin_color, ..)\n | Self::Lch(origin_color, ..)\n | Self::Oklab(origin_color, ..)\n | Self::Oklch(origin_color, ..)\n | Self::Color(origin_color, ..) => origin_color.is_some(),\n }\n }\n\n /// Try to resolve the color function to an [`AbsoluteColor`] that does not\n /// contain any variables (currentcolor, color components, etc.).\n pub fn resolve_to_absolute(&self) -> Result {\n // Map the color function to one with an absolute origin color.\n self.map_origin_color(|o| o.resolve_to_absolute())?\n .resolve_to_absolute()\n }\n}\n\nimpl ColorFunction {\n /// Map the origin color to another type.\n pub fn map_origin_color(\n &self,\n f: impl FnOnce(&Color) -> Result,\n ) -> Result, ()> {\n macro_rules! map {\n ($f:ident, $o:expr, $c0:expr, $c1:expr, $c2:expr, $alpha:expr) => {{\n ColorFunction::$f(\n match $o.as_ref() {\n Some(c) => Some(f(c)?),\n None => None,\n }\n .into(),\n $c0.clone(),\n $c1.clone(),\n $c2.clone(),\n $alpha.clone(),\n )\n }};\n }\n Ok(match self {\n ColorFunction::Rgb(o, c0, c1, c2, alpha) => map!(Rgb, o, c0, c1, c2, alpha),\n ColorFunction::Hsl(o, c0, c1, c2, alpha) => map!(Hsl, o, c0, c1, c2, alpha),\n ColorFunction::Hwb(o, c0, c1, c2, alpha) => map!(Hwb, o, c0, c1, c2, alpha),\n ColorFunction::Lab(o, c0, c1, c2, alpha) => map!(Lab, o, c0, c1, c2, alpha),\n ColorFunction::Lch(o, c0, c1, c2, alpha) => map!(Lch, o, c0, c1, c2, alpha),\n ColorFunction::Oklab(o, c0, c1, c2, alpha) => map!(Oklab, o, c0, c1, c2, alpha),\n ColorFunction::Oklch(o, c0, c1, c2, alpha) => map!(Oklch, o, c0, c1, c2, alpha),\n ColorFunction::Color(o, c0, c1, c2, alpha, color_space) => ColorFunction::Color(\n match o.as_ref() {\n Some(c) => Some(f(c)?),\n None => None,\n }\n .into(),\n c0.clone(),\n c1.clone(),\n c2.clone(),\n alpha.clone(),\n color_space.clone(),\n ),\n })\n }\n}\n\nimpl ColorFunction {\n /// Resolve a computed color function to an absolute computed color.\n pub fn resolve_to_absolute(&self, current_color: &AbsoluteColor) -> AbsoluteColor {\n // Map the color function to one with an absolute origin color.\n let resolvable = self\n .map_origin_color(|o| Ok(o.resolve_to_absolute(current_color)))\n .unwrap();\n match resolvable.resolve_to_absolute() {\n Ok(color) => color,\n Err(..) => {\n debug_assert!(\n false,\n \"the color could not be resolved even with a currentcolor specified?\"\n );\n AbsoluteColor::TRANSPARENT_BLACK\n },\n }\n }\n}\n\nimpl style_traits::ToCss for ColorFunction {\n fn to_css(&self, dest: &mut style_traits::CssWriter) -> std::fmt::Result\n where\n W: std::fmt::Write,\n {\n let (origin_color, alpha) = match self {\n Self::Rgb(origin_color, _, _, _, alpha) => {\n dest.write_str(\"rgb(\")?;\n (origin_color, alpha)\n },\n Self::Hsl(origin_color, _, _, _, alpha) => {\n dest.write_str(\"hsl(\")?;\n (origin_color, alpha)\n },\n Self::Hwb(origin_color, _, _, _, alpha) => {\n dest.write_str(\"hwb(\")?;\n (origin_color, alpha)\n },\n Self::Lab(origin_color, _, _, _, alpha) => {\n dest.write_str(\"lab(\")?;\n (origin_color, alpha)\n },\n Self::Lch(origin_color, _, _, _, alpha) => {\n dest.write_str(\"lch(\")?;\n (origin_color, alpha)\n },\n Self::Oklab(origin_color, _, _, _, alpha) => {\n dest.write_str(\"oklab(\")?;\n (origin_color, alpha)\n },\n Self::Oklch(origin_color, _, _, _, alpha) => {\n dest.write_str(\"oklch(\")?;\n (origin_color, alpha)\n },\n Self::Color(origin_color, _, _, _, alpha, _) => {\n dest.write_str(\"color(\")?;\n (origin_color, alpha)\n },\n };\n\n if let Optional::Some(origin_color) = origin_color {\n dest.write_str(\"from \")?;\n origin_color.to_css(dest)?;\n dest.write_str(\" \")?;\n }\n\n let is_opaque = if let ColorComponent::Value(value) = *alpha {\n value.to_number(OPAQUE) == OPAQUE\n } else {\n false\n };\n\n macro_rules! serialize_alpha {\n ($alpha_component:expr) => {{\n if !is_opaque && !matches!($alpha_component, ColorComponent::AlphaOmitted) {\n dest.write_str(\" / \")?;\n $alpha_component.to_css(dest)?;\n }\n }};\n }\n\n macro_rules! serialize_components {\n ($c0:expr, $c1:expr, $c2:expr) => {{\n debug_assert!(!matches!($c0, ColorComponent::AlphaOmitted));\n debug_assert!(!matches!($c1, ColorComponent::AlphaOmitted));\n debug_assert!(!matches!($c2, ColorComponent::AlphaOmitted));\n\n $c0.to_css(dest)?;\n dest.write_str(\" \")?;\n $c1.to_css(dest)?;\n dest.write_str(\" \")?;\n $c2.to_css(dest)?;\n }};\n }\n\n match self {\n Self::Rgb(_, c0, c1, c2, alpha) => {\n serialize_components!(c0, c1, c2);\n serialize_alpha!(alpha);\n },\n Self::Hsl(_, c0, c1, c2, alpha) => {\n serialize_components!(c0, c1, c2);\n serialize_alpha!(alpha);\n },\n Self::Hwb(_, c0, c1, c2, alpha) => {\n serialize_components!(c0, c1, c2);\n serialize_alpha!(alpha);\n },\n Self::Lab(_, c0, c1, c2, alpha) => {\n serialize_components!(c0, c1, c2);\n serialize_alpha!(alpha);\n },\n Self::Lch(_, c0, c1, c2, alpha) => {\n serialize_components!(c0, c1, c2);\n serialize_alpha!(alpha);\n },\n Self::Oklab(_, c0, c1, c2, alpha) => {\n serialize_components!(c0, c1, c2);\n serialize_alpha!(alpha);\n },\n Self::Oklch(_, c0, c1, c2, alpha) => {\n serialize_components!(c0, c1, c2);\n serialize_alpha!(alpha);\n },\n Self::Color(_, c0, c1, c2, alpha, color_space) => {\n color_space.to_css(dest)?;\n dest.write_str(\" \")?;\n serialize_components!(c0, c1, c2);\n serialize_alpha!(alpha);\n },\n }\n\n dest.write_str(\")\")\n }\n}\n" }, { "path": "style/color/component.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! Parse/serialize and resolve a single color component.\n\nuse std::fmt::Write;\n\nuse super::{\n parsing::{rcs_enabled, ChannelKeyword},\n AbsoluteColor,\n};\nuse crate::derives::*;\nuse crate::{\n parser::ParserContext,\n values::{\n animated::ToAnimatedValue,\n generics::calc::{CalcUnits, GenericCalcNode},\n specified::calc::{AllowParse, Leaf},\n },\n};\nuse cssparser::{color::OPAQUE, Parser, Token};\nuse style_traits::{ParseError, ToCss};\n\n/// A single color component.\n#[derive(Clone, Debug, MallocSizeOf, PartialEq, ToShmem)]\n#[repr(u8)]\npub enum ColorComponent {\n /// The \"none\" keyword.\n None,\n /// A absolute value.\n Value(ValueType),\n /// A channel keyword, e.g. `r`, `l`, `alpha`, etc.\n ChannelKeyword(ChannelKeyword),\n /// A calc() value.\n Calc(Box>),\n /// Used when alpha components are not specified.\n AlphaOmitted,\n}\n\nimpl ColorComponent {\n /// Return true if the component is \"none\".\n #[inline]\n pub fn is_none(&self) -> bool {\n matches!(self, Self::None)\n }\n}\n\n/// An utility trait that allows the construction of [ColorComponent]\n/// `ValueType`'s after parsing a color component.\npub trait ColorComponentType: Sized + Clone {\n // TODO(tlouw): This function should be named according to the rules in the spec\n // stating that all the values coming from color components are\n // numbers and that each has their own rules dependeing on types.\n /// Construct a new component from a single value.\n fn from_value(value: f32) -> Self;\n\n /// Return the [CalcUnits] flags that the impl can handle.\n fn units() -> CalcUnits;\n\n /// Try to create a new component from the given token.\n fn try_from_token(token: &Token) -> Result;\n\n /// Try to create a new component from the given [CalcNodeLeaf] that was\n /// resolved from a [CalcNode].\n fn try_from_leaf(leaf: &Leaf) -> Result;\n}\n\nimpl ColorComponent {\n /// Parse a single [ColorComponent].\n pub fn parse<'i, 't>(\n context: &ParserContext,\n input: &mut Parser<'i, 't>,\n allow_none: bool,\n ) -> Result> {\n let location = input.current_source_location();\n\n match *input.next()? {\n Token::Ident(ref value) if allow_none && value.eq_ignore_ascii_case(\"none\") => {\n Ok(ColorComponent::None)\n },\n ref t @ Token::Ident(ref ident) => {\n let Ok(channel_keyword) = ChannelKeyword::from_ident(ident) else {\n return Err(location.new_unexpected_token_error(t.clone()));\n };\n Ok(ColorComponent::ChannelKeyword(channel_keyword))\n },\n Token::Function(ref name) => {\n let function = GenericCalcNode::math_function(context, name, location)?;\n let allow = AllowParse::new(if rcs_enabled() {\n ValueType::units() | CalcUnits::COLOR_COMPONENT\n } else {\n ValueType::units()\n });\n let mut node = GenericCalcNode::parse(context, input, function, allow)?;\n\n // TODO(tlouw): We only have to simplify the node when we have to store it, but we\n // only know if we have to store it much later when the whole color\n // can't be resolved to absolute at which point the calc nodes are\n // burried deep in a [ColorFunction] struct.\n node.simplify_and_sort();\n\n Ok(Self::Calc(Box::new(node)))\n },\n ref t => ValueType::try_from_token(t)\n .map(Self::Value)\n .map_err(|_| location.new_unexpected_token_error(t.clone())),\n }\n }\n\n /// Resolve a [ColorComponent] into a float. None is \"none\".\n pub fn resolve(&self, origin_color: Option<&AbsoluteColor>) -> Result, ()> {\n Ok(match self {\n ColorComponent::None => None,\n ColorComponent::Value(value) => Some(value.clone()),\n ColorComponent::ChannelKeyword(channel_keyword) => match origin_color {\n Some(origin_color) => {\n let value = origin_color.get_component_by_channel_keyword(*channel_keyword)?;\n Some(ValueType::from_value(value.unwrap_or(0.0)))\n },\n None => return Err(()),\n },\n ColorComponent::Calc(node) => {\n let Ok(resolved_leaf) = node.resolve_map(|leaf| {\n Ok(match leaf {\n Leaf::ColorComponent(channel_keyword) => match origin_color {\n Some(origin_color) => {\n let value = origin_color\n .get_component_by_channel_keyword(*channel_keyword)?;\n Leaf::Number(value.unwrap_or(0.0))\n },\n None => return Err(()),\n },\n l => l.clone(),\n })\n }) else {\n return Err(());\n };\n\n Some(ValueType::try_from_leaf(&resolved_leaf)?)\n },\n ColorComponent::AlphaOmitted => {\n if let Some(origin_color) = origin_color {\n // \n // If the alpha value of the relative color is omitted, it defaults to that of\n // the origin color (rather than defaulting to 100%, as it does in the absolute\n // syntax).\n origin_color.alpha().map(ValueType::from_value)\n } else {\n Some(ValueType::from_value(OPAQUE))\n }\n },\n })\n }\n}\n\nimpl ToCss for ColorComponent {\n fn to_css(&self, dest: &mut style_traits::CssWriter) -> std::fmt::Result\n where\n W: Write,\n {\n match self {\n ColorComponent::None => dest.write_str(\"none\")?,\n ColorComponent::Value(value) => value.to_css(dest)?,\n ColorComponent::ChannelKeyword(channel_keyword) => channel_keyword.to_css(dest)?,\n ColorComponent::Calc(node) => {\n // When we only have a channel keyword in a leaf node, we should serialize it with\n // calc(..), except when one of the rgb color space functions are used, e.g.\n // rgb(..), hsl(..) or hwb(..) for historical reasons.\n // \n node.to_css(dest)?;\n },\n ColorComponent::AlphaOmitted => {\n debug_assert!(false, \"can't serialize an omitted alpha component\");\n },\n }\n\n Ok(())\n }\n}\n\nimpl ToAnimatedValue for ColorComponent {\n type AnimatedValue = Self;\n\n fn to_animated_value(self, _context: &crate::values::animated::Context) -> Self::AnimatedValue {\n self\n }\n\n fn from_animated_value(animated: Self::AnimatedValue) -> Self {\n animated\n }\n}\n" }, { "path": "style/color/convert.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! Color conversion algorithms.\n//!\n//! Algorithms, matrices and constants are from the [color-4] specification,\n//! unless otherwise specified:\n//!\n//! https://drafts.csswg.org/css-color-4/#color-conversion-code\n//!\n//! NOTE: Matrices has to be transposed from the examples in the spec for use\n//! with the `euclid` library.\n\nuse crate::color::ColorComponents;\nuse crate::values::normalize;\n\ntype Transform = euclid::default::Transform3D;\ntype Vector = euclid::default::Vector3D;\n\n/// Normalize hue into [0, 360).\n#[inline]\npub fn normalize_hue(hue: f32) -> f32 {\n hue - 360. * (hue / 360.).floor()\n}\n\n/// Calculate the hue from RGB components and return it along with the min and\n/// max RGB values.\n#[inline]\nfn rgb_to_hue_min_max(red: f32, green: f32, blue: f32) -> (f32, f32, f32) {\n let max = red.max(green).max(blue);\n let min = red.min(green).min(blue);\n\n let delta = max - min;\n\n let hue = if delta != 0.0 {\n 60.0 * if max == red {\n (green - blue) / delta + if green < blue { 6.0 } else { 0.0 }\n } else if max == green {\n (blue - red) / delta + 2.0\n } else {\n (red - green) / delta + 4.0\n }\n } else {\n f32::NAN\n };\n\n (hue, min, max)\n}\n\n/// Convert from HSL notation to RGB notation.\n/// https://drafts.csswg.org/css-color-4/#hsl-to-rgb\n#[inline]\npub fn hsl_to_rgb(from: &ColorComponents) -> ColorComponents {\n fn hue_to_rgb(t1: f32, t2: f32, hue: f32) -> f32 {\n let hue = normalize_hue(hue);\n\n if hue * 6.0 < 360.0 {\n t1 + (t2 - t1) * hue / 60.0\n } else if hue * 2.0 < 360.0 {\n t2\n } else if hue * 3.0 < 720.0 {\n t1 + (t2 - t1) * (240.0 - hue) / 60.0\n } else {\n t1\n }\n }\n\n // Convert missing components to 0.0.\n let ColorComponents(hue, saturation, lightness) = from.map(normalize);\n let saturation = saturation / 100.0;\n let lightness = lightness / 100.0;\n\n let t2 = if lightness <= 0.5 {\n lightness * (saturation + 1.0)\n } else {\n lightness + saturation - lightness * saturation\n };\n let t1 = lightness * 2.0 - t2;\n\n ColorComponents(\n hue_to_rgb(t1, t2, hue + 120.0),\n hue_to_rgb(t1, t2, hue),\n hue_to_rgb(t1, t2, hue - 120.0),\n )\n}\n\n/// Convert from RGB notation to HSL notation.\n/// https://drafts.csswg.org/css-color-4/#rgb-to-hsl\npub fn rgb_to_hsl(from: &ColorComponents) -> ColorComponents {\n let ColorComponents(red, green, blue) = *from;\n\n let (hue, min, max) = rgb_to_hue_min_max(red, green, blue);\n\n let lightness = (min + max) / 2.0;\n let delta = max - min;\n\n let saturation = if delta != 0.0 {\n if lightness == 0.0 || lightness == 1.0 {\n 0.0\n } else {\n (max - lightness) / lightness.min(1.0 - lightness)\n }\n } else {\n 0.0\n };\n\n ColorComponents(hue, saturation * 100.0, lightness * 100.0)\n}\n\n/// Convert from HWB notation to RGB notation.\n/// https://drafts.csswg.org/css-color-4/#hwb-to-rgb\n#[inline]\npub fn hwb_to_rgb(from: &ColorComponents) -> ColorComponents {\n // Convert missing components to 0.0.\n let ColorComponents(hue, whiteness, blackness) = from.map(normalize);\n\n let whiteness = whiteness / 100.0;\n let blackness = blackness / 100.0;\n\n if whiteness + blackness >= 1.0 {\n let gray = whiteness / (whiteness + blackness);\n return ColorComponents(gray, gray, gray);\n }\n\n let x = 1.0 - whiteness - blackness;\n hsl_to_rgb(&ColorComponents(hue, 100.0, 50.0)).map(|v| v * x + whiteness)\n}\n\n/// Convert from RGB notation to HWB notation.\n/// https://drafts.csswg.org/css-color-4/#rgb-to-hwb\n#[inline]\npub fn rgb_to_hwb(from: &ColorComponents) -> ColorComponents {\n let ColorComponents(red, green, blue) = *from;\n\n let (hue, min, max) = rgb_to_hue_min_max(red, green, blue);\n\n let whiteness = min;\n let blackness = 1.0 - max;\n\n ColorComponents(hue, whiteness * 100.0, blackness * 100.0)\n}\n\n/// Calculate an epsilon for a specified range.\n#[inline]\npub fn epsilon_for_range(min: f32, max: f32) -> f32 {\n (max - min) / 1.0e5\n}\n\n/// Convert from the rectangular orthogonal to the cylindrical polar coordinate\n/// system. This is used to convert (ok)lab to (ok)lch.\n/// \n#[inline]\npub fn orthogonal_to_polar(from: &ColorComponents, e: f32) -> ColorComponents {\n let ColorComponents(lightness, a, b) = *from;\n\n let chroma = (a * a + b * b).sqrt();\n\n let hue = if a.abs() < e && b.abs() < e {\n // For extremely small values of a and b ... the reported hue angle\n // swinging about wildly and being essentially random ... this means\n // the hue is powerless, and treated as missing when converted into LCH\n // or Oklch.\n f32::NAN\n } else if chroma.abs() < e {\n // Very small chroma values make the hue component powerless.\n f32::NAN\n } else {\n normalize_hue(b.atan2(a).to_degrees())\n };\n\n ColorComponents(lightness, chroma, hue)\n}\n\n/// Convert from the cylindrical polar to the rectangular orthogonal coordinate\n/// system. This is used to convert (ok)lch to (ok)lab.\n/// \n#[inline]\npub fn polar_to_orthogonal(from: &ColorComponents) -> ColorComponents {\n let ColorComponents(lightness, chroma, hue) = *from;\n\n // A missing hue component results in an achromatic color.\n if hue.is_nan() {\n return ColorComponents(lightness, 0.0, 0.0);\n }\n\n let hue = hue.to_radians();\n let a = chroma * hue.cos();\n let b = chroma * hue.sin();\n\n ColorComponents(lightness, a, b)\n}\n\n#[inline]\nfn transform(from: &ColorComponents, mat: &Transform) -> ColorComponents {\n let result = mat.transform_vector3d(Vector::new(from.0, from.1, from.2));\n ColorComponents(result.x, result.y, result.z)\n}\n\nfn xyz_d65_to_xyz_d50(from: &ColorComponents) -> ColorComponents {\n #[rustfmt::skip]\n const MAT: Transform = Transform::new(\n 1.0479298208405488, 0.029627815688159344, -0.009243058152591178, 0.0,\n 0.022946793341019088, 0.990434484573249, 0.015055144896577895, 0.0,\n -0.05019222954313557, -0.01707382502938514, 0.7518742899580008, 0.0,\n 0.0, 0.0, 0.0, 1.0,\n );\n\n transform(from, &MAT)\n}\n\nfn xyz_d50_to_xyz_d65(from: &ColorComponents) -> ColorComponents {\n #[rustfmt::skip]\n const MAT: Transform = Transform::new(\n 0.9554734527042182, -0.028369706963208136, 0.012314001688319899, 0.0,\n -0.023098536874261423, 1.0099954580058226, -0.020507696433477912, 0.0,\n 0.0632593086610217, 0.021041398966943008, 1.3303659366080753, 0.0,\n 0.0, 0.0, 0.0, 1.0,\n );\n\n transform(from, &MAT)\n}\n\n/// A reference white that is used during color conversion.\npub enum WhitePoint {\n /// D50 white reference.\n D50,\n /// D65 white reference.\n D65,\n}\n\nimpl WhitePoint {\n const fn values(&self) -> ColorComponents {\n // \n match self {\n // [0.3457 / 0.3585, 1.00000, (1.0 - 0.3457 - 0.3585) / 0.3585]\n WhitePoint::D50 => ColorComponents(0.9642956764295677, 1.0, 0.8251046025104602),\n // [0.3127 / 0.3290, 1.00000, (1.0 - 0.3127 - 0.3290) / 0.3290]\n WhitePoint::D65 => ColorComponents(0.9504559270516716, 1.0, 1.0890577507598784),\n }\n }\n}\n\nfn convert_white_point(from: WhitePoint, to: WhitePoint, components: &mut ColorComponents) {\n match (from, to) {\n (WhitePoint::D50, WhitePoint::D65) => *components = xyz_d50_to_xyz_d65(components),\n (WhitePoint::D65, WhitePoint::D50) => *components = xyz_d65_to_xyz_d50(components),\n _ => {},\n }\n}\n\n/// A trait that allows conversion of color spaces to and from XYZ coordinate\n/// space with a specified white point.\n///\n/// Allows following the specified method of converting between color spaces:\n/// - Convert to values to sRGB linear light.\n/// - Convert to XYZ coordinate space.\n/// - Adjust white point to target white point.\n/// - Convert to sRGB linear light in target color space.\n/// - Convert to sRGB gamma encoded in target color space.\n///\n/// https://drafts.csswg.org/css-color-4/#color-conversion\npub trait ColorSpaceConversion {\n /// The white point that the implementer is represented in.\n const WHITE_POINT: WhitePoint;\n\n /// Convert the components from sRGB gamma encoded values to sRGB linear\n /// light values.\n fn to_linear_light(from: &ColorComponents) -> ColorComponents;\n\n /// Convert the components from sRGB linear light values to XYZ coordinate\n /// space.\n fn to_xyz(from: &ColorComponents) -> ColorComponents;\n\n /// Convert the components from XYZ coordinate space to sRGB linear light\n /// values.\n fn from_xyz(from: &ColorComponents) -> ColorComponents;\n\n /// Convert the components from sRGB linear light values to sRGB gamma\n /// encoded values.\n fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents;\n}\n\n/// Convert the color components from the specified color space to XYZ and\n/// return the components and the white point they are in.\npub fn to_xyz(from: &ColorComponents) -> (ColorComponents, WhitePoint) {\n // Convert the color components where in-gamut values are in the range\n // [0 - 1] to linear light (un-companded) form.\n let result = From::to_linear_light(from);\n\n // Convert the color components from the source color space to XYZ.\n (From::to_xyz(&result), From::WHITE_POINT)\n}\n\n/// Convert the color components from XYZ at the given white point to the\n/// specified color space.\npub fn from_xyz(\n from: &ColorComponents,\n white_point: WhitePoint,\n) -> ColorComponents {\n let mut xyz = from.clone();\n\n // Convert the white point if needed.\n convert_white_point(white_point, To::WHITE_POINT, &mut xyz);\n\n // Convert the color from XYZ to the target color space.\n let result = To::from_xyz(&xyz);\n\n // Convert the color components of linear-light values in the range\n // [0 - 1] to a gamma corrected form.\n To::to_gamma_encoded(&result)\n}\n\n/// The sRGB color space.\n/// https://drafts.csswg.org/css-color-4/#predefined-sRGB\npub struct Srgb;\n\nimpl Srgb {\n #[rustfmt::skip]\n const TO_XYZ: Transform = Transform::new(\n 0.4123907992659595, 0.21263900587151036, 0.01933081871559185, 0.0,\n 0.35758433938387796, 0.7151686787677559, 0.11919477979462599, 0.0,\n 0.1804807884018343, 0.07219231536073371, 0.9505321522496606, 0.0,\n 0.0, 0.0, 0.0, 1.0,\n );\n\n #[rustfmt::skip]\n const FROM_XYZ: Transform = Transform::new(\n 3.2409699419045213, -0.9692436362808798, 0.05563007969699361, 0.0,\n -1.5373831775700935, 1.8759675015077206, -0.20397695888897657, 0.0,\n -0.4986107602930033, 0.04155505740717561, 1.0569715142428786, 0.0,\n 0.0, 0.0, 0.0, 1.0,\n );\n}\n\nimpl ColorSpaceConversion for Srgb {\n const WHITE_POINT: WhitePoint = WhitePoint::D65;\n\n fn to_linear_light(from: &ColorComponents) -> ColorComponents {\n from.clone().map(|value| {\n let abs = value.abs();\n\n if abs < 0.04045 {\n value / 12.92\n } else {\n value.signum() * ((abs + 0.055) / 1.055).powf(2.4)\n }\n })\n }\n\n fn to_xyz(from: &ColorComponents) -> ColorComponents {\n transform(from, &Self::TO_XYZ)\n }\n\n fn from_xyz(from: &ColorComponents) -> ColorComponents {\n transform(from, &Self::FROM_XYZ)\n }\n\n fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {\n from.clone().map(|value| {\n let abs = value.abs();\n\n if abs > 0.0031308 {\n value.signum() * (1.055 * abs.powf(1.0 / 2.4) - 0.055)\n } else {\n 12.92 * value\n }\n })\n }\n}\n\n/// Color specified with hue, saturation and lightness components.\npub struct Hsl;\n\nimpl ColorSpaceConversion for Hsl {\n const WHITE_POINT: WhitePoint = Srgb::WHITE_POINT;\n\n fn to_linear_light(from: &ColorComponents) -> ColorComponents {\n Srgb::to_linear_light(&hsl_to_rgb(from))\n }\n\n #[inline]\n fn to_xyz(from: &ColorComponents) -> ColorComponents {\n Srgb::to_xyz(from)\n }\n\n #[inline]\n fn from_xyz(from: &ColorComponents) -> ColorComponents {\n Srgb::from_xyz(from)\n }\n\n fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {\n rgb_to_hsl(&Srgb::to_gamma_encoded(from))\n }\n}\n\n/// Color specified with hue, whiteness and blackness components.\npub struct Hwb;\n\nimpl ColorSpaceConversion for Hwb {\n const WHITE_POINT: WhitePoint = Srgb::WHITE_POINT;\n\n fn to_linear_light(from: &ColorComponents) -> ColorComponents {\n Srgb::to_linear_light(&hwb_to_rgb(from))\n }\n\n #[inline]\n fn to_xyz(from: &ColorComponents) -> ColorComponents {\n Srgb::to_xyz(from)\n }\n\n #[inline]\n fn from_xyz(from: &ColorComponents) -> ColorComponents {\n Srgb::from_xyz(from)\n }\n\n fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {\n rgb_to_hwb(&Srgb::to_gamma_encoded(from))\n }\n}\n\n/// The same as sRGB color space, except the transfer function is linear light.\n/// https://drafts.csswg.org/css-color-4/#predefined-sRGB-linear\npub struct SrgbLinear;\n\nimpl ColorSpaceConversion for SrgbLinear {\n const WHITE_POINT: WhitePoint = Srgb::WHITE_POINT;\n\n fn to_linear_light(from: &ColorComponents) -> ColorComponents {\n // Already in linear light form.\n from.clone()\n }\n\n fn to_xyz(from: &ColorComponents) -> ColorComponents {\n Srgb::to_xyz(from)\n }\n\n fn from_xyz(from: &ColorComponents) -> ColorComponents {\n Srgb::from_xyz(from)\n }\n\n fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {\n // Stay in linear light form.\n from.clone()\n }\n}\n\n/// The Display-P3 color space.\n/// https://drafts.csswg.org/css-color-4/#predefined-display-p3\npub struct DisplayP3;\n\nimpl DisplayP3 {\n #[rustfmt::skip]\n const TO_XYZ: Transform = Transform::new(\n 0.48657094864821626, 0.22897456406974884, 0.0, 0.0,\n 0.26566769316909294, 0.6917385218365062, 0.045113381858902575, 0.0,\n 0.1982172852343625, 0.079286914093745, 1.0439443689009757, 0.0,\n 0.0, 0.0, 0.0, 1.0,\n );\n\n #[rustfmt::skip]\n const FROM_XYZ: Transform = Transform::new(\n 2.4934969119414245, -0.829488969561575, 0.035845830243784335, 0.0,\n -0.9313836179191236, 1.7626640603183468, -0.07617238926804171, 0.0,\n -0.40271078445071684, 0.02362468584194359, 0.9568845240076873, 0.0,\n 0.0, 0.0, 0.0, 1.0,\n );\n}\n\nimpl ColorSpaceConversion for DisplayP3 {\n const WHITE_POINT: WhitePoint = WhitePoint::D65;\n\n fn to_linear_light(from: &ColorComponents) -> ColorComponents {\n Srgb::to_linear_light(from)\n }\n\n fn to_xyz(from: &ColorComponents) -> ColorComponents {\n transform(from, &Self::TO_XYZ)\n }\n\n fn from_xyz(from: &ColorComponents) -> ColorComponents {\n transform(from, &Self::FROM_XYZ)\n }\n\n fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {\n Srgb::to_gamma_encoded(from)\n }\n}\n\n/// The Display-P3-linear color space. This is basically display-p3 without gamma encoding.\npub struct DisplayP3Linear;\nimpl ColorSpaceConversion for DisplayP3Linear {\n const WHITE_POINT: WhitePoint = DisplayP3::WHITE_POINT;\n\n fn to_linear_light(from: &ColorComponents) -> ColorComponents {\n *from\n }\n\n fn to_xyz(from: &ColorComponents) -> ColorComponents {\n DisplayP3::to_xyz(from)\n }\n\n fn from_xyz(from: &ColorComponents) -> ColorComponents {\n DisplayP3::from_xyz(from)\n }\n\n fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {\n *from\n }\n}\n\n/// The a98-rgb color space.\n/// https://drafts.csswg.org/css-color-4/#predefined-a98-rgb\npub struct A98Rgb;\n\nimpl A98Rgb {\n #[rustfmt::skip]\n const TO_XYZ: Transform = Transform::new(\n 0.5766690429101308, 0.29734497525053616, 0.027031361386412378, 0.0,\n 0.18555823790654627, 0.627363566255466, 0.07068885253582714, 0.0,\n 0.18822864623499472, 0.07529145849399789, 0.9913375368376389, 0.0,\n 0.0, 0.0, 0.0, 1.0,\n );\n\n #[rustfmt::skip]\n const FROM_XYZ: Transform = Transform::new(\n 2.041587903810746, -0.9692436362808798, 0.013444280632031024, 0.0,\n -0.5650069742788596, 1.8759675015077206, -0.11836239223101824, 0.0,\n -0.3447313507783295, 0.04155505740717561, 1.0151749943912054, 0.0,\n 0.0, 0.0, 0.0, 1.0,\n );\n}\n\nimpl ColorSpaceConversion for A98Rgb {\n const WHITE_POINT: WhitePoint = WhitePoint::D65;\n\n fn to_linear_light(from: &ColorComponents) -> ColorComponents {\n from.clone().map(|v| v.signum() * v.abs().powf(2.19921875))\n }\n\n fn to_xyz(from: &ColorComponents) -> ColorComponents {\n transform(from, &Self::TO_XYZ)\n }\n\n fn from_xyz(from: &ColorComponents) -> ColorComponents {\n transform(from, &Self::FROM_XYZ)\n }\n\n fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {\n from.clone()\n .map(|v| v.signum() * v.abs().powf(0.4547069271758437))\n }\n}\n\n/// The ProPhoto RGB color space.\n/// https://drafts.csswg.org/css-color-4/#predefined-prophoto-rgb\npub struct ProphotoRgb;\n\nimpl ProphotoRgb {\n #[rustfmt::skip]\n const TO_XYZ: Transform = Transform::new(\n 0.7977604896723027, 0.2880711282292934, 0.0, 0.0,\n 0.13518583717574031, 0.7118432178101014, 0.0, 0.0,\n 0.0313493495815248, 0.00008565396060525902, 0.8251046025104601, 0.0,\n 0.0, 0.0, 0.0, 1.0,\n );\n\n #[rustfmt::skip]\n const FROM_XYZ: Transform = Transform::new(\n 1.3457989731028281, -0.5446224939028347, 0.0, 0.0,\n -0.25558010007997534, 1.5082327413132781, 0.0, 0.0,\n -0.05110628506753401, 0.02053603239147973, 1.2119675456389454, 0.0,\n 0.0, 0.0, 0.0, 1.0,\n );\n}\n\nimpl ColorSpaceConversion for ProphotoRgb {\n const WHITE_POINT: WhitePoint = WhitePoint::D50;\n\n fn to_linear_light(from: &ColorComponents) -> ColorComponents {\n from.clone().map(|value| {\n const ET2: f32 = 16.0 / 512.0;\n\n let abs = value.abs();\n\n if abs <= ET2 {\n value / 16.0\n } else {\n value.signum() * abs.powf(1.8)\n }\n })\n }\n\n fn to_xyz(from: &ColorComponents) -> ColorComponents {\n transform(from, &Self::TO_XYZ)\n }\n\n fn from_xyz(from: &ColorComponents) -> ColorComponents {\n transform(from, &Self::FROM_XYZ)\n }\n\n fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {\n const ET: f32 = 1.0 / 512.0;\n\n from.clone().map(|v| {\n let abs = v.abs();\n if abs >= ET {\n v.signum() * abs.powf(1.0 / 1.8)\n } else {\n 16.0 * v\n }\n })\n }\n}\n\n/// The Rec.2020 color space.\n/// https://drafts.csswg.org/css-color-4/#predefined-rec2020\npub struct Rec2020;\n\nimpl Rec2020 {\n const ALPHA: f32 = 1.09929682680944;\n const BETA: f32 = 0.018053968510807;\n\n #[rustfmt::skip]\n const TO_XYZ: Transform = Transform::new(\n 0.6369580483012913, 0.26270021201126703, 0.0, 0.0,\n 0.14461690358620838, 0.677998071518871, 0.028072693049087508, 0.0,\n 0.16888097516417205, 0.059301716469861945, 1.0609850577107909, 0.0,\n 0.0, 0.0, 0.0, 1.0,\n );\n\n #[rustfmt::skip]\n const FROM_XYZ: Transform = Transform::new(\n 1.7166511879712676, -0.666684351832489, 0.017639857445310915, 0.0,\n -0.3556707837763924, 1.616481236634939, -0.042770613257808655, 0.0,\n -0.2533662813736598, 0.01576854581391113, 0.942103121235474, 0.0,\n 0.0, 0.0, 0.0, 1.0,\n );\n}\n\nimpl ColorSpaceConversion for Rec2020 {\n const WHITE_POINT: WhitePoint = WhitePoint::D65;\n\n fn to_linear_light(from: &ColorComponents) -> ColorComponents {\n from.clone().map(|value| {\n let abs = value.abs();\n\n if abs < Self::BETA * 4.5 {\n value / 4.5\n } else {\n value.signum() * ((abs + Self::ALPHA - 1.0) / Self::ALPHA).powf(1.0 / 0.45)\n }\n })\n }\n\n fn to_xyz(from: &ColorComponents) -> ColorComponents {\n transform(from, &Self::TO_XYZ)\n }\n\n fn from_xyz(from: &ColorComponents) -> ColorComponents {\n transform(from, &Self::FROM_XYZ)\n }\n\n fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {\n from.clone().map(|v| {\n let abs = v.abs();\n\n if abs > Self::BETA {\n v.signum() * (Self::ALPHA * abs.powf(0.45) - (Self::ALPHA - 1.0))\n } else {\n 4.5 * v\n }\n })\n }\n}\n\n/// A color in the XYZ coordinate space with a D50 white reference.\n/// https://drafts.csswg.org/css-color-4/#predefined-xyz\npub struct XyzD50;\n\nimpl ColorSpaceConversion for XyzD50 {\n const WHITE_POINT: WhitePoint = WhitePoint::D50;\n\n fn to_linear_light(from: &ColorComponents) -> ColorComponents {\n from.clone()\n }\n\n fn to_xyz(from: &ColorComponents) -> ColorComponents {\n from.clone()\n }\n\n fn from_xyz(from: &ColorComponents) -> ColorComponents {\n from.clone()\n }\n\n fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {\n from.clone()\n }\n}\n\n/// A color in the XYZ coordinate space with a D65 white reference.\n/// https://drafts.csswg.org/css-color-4/#predefined-xyz\npub struct XyzD65;\n\nimpl ColorSpaceConversion for XyzD65 {\n const WHITE_POINT: WhitePoint = WhitePoint::D65;\n\n fn to_linear_light(from: &ColorComponents) -> ColorComponents {\n from.clone()\n }\n\n fn to_xyz(from: &ColorComponents) -> ColorComponents {\n from.clone()\n }\n\n fn from_xyz(from: &ColorComponents) -> ColorComponents {\n from.clone()\n }\n\n fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {\n from.clone()\n }\n}\n\n/// The Lab color space.\n/// https://drafts.csswg.org/css-color-4/#specifying-lab-lch\npub struct Lab;\n\nimpl Lab {\n const KAPPA: f32 = 24389.0 / 27.0;\n const EPSILON: f32 = 216.0 / 24389.0;\n}\n\nimpl ColorSpaceConversion for Lab {\n const WHITE_POINT: WhitePoint = WhitePoint::D50;\n\n fn to_linear_light(from: &ColorComponents) -> ColorComponents {\n // No need for conversion.\n from.clone()\n }\n\n /// Convert a CIELAB color to XYZ as specified in [1] and [2].\n ///\n /// [1]: https://drafts.csswg.org/css-color/#lab-to-predefined\n /// [2]: https://drafts.csswg.org/css-color/#color-conversion-code\n fn to_xyz(from: &ColorComponents) -> ColorComponents {\n let ColorComponents(lightness, a, b) = *from;\n\n let f1 = (lightness + 16.0) / 116.0;\n let f0 = f1 + a / 500.0;\n let f2 = f1 - b / 200.0;\n\n let f0_cubed = f0 * f0 * f0;\n let x = if f0_cubed > Self::EPSILON {\n f0_cubed\n } else {\n (116.0 * f0 - 16.0) / Self::KAPPA\n };\n\n let y = if lightness > Self::KAPPA * Self::EPSILON {\n let v = (lightness + 16.0) / 116.0;\n v * v * v\n } else {\n lightness / Self::KAPPA\n };\n\n let f2_cubed = f2 * f2 * f2;\n let z = if f2_cubed > Self::EPSILON {\n f2_cubed\n } else {\n (116.0 * f2 - 16.0) / Self::KAPPA\n };\n\n ColorComponents(x, y, z) * Self::WHITE_POINT.values()\n }\n\n /// Convert an XYZ color to LAB as specified in [1] and [2].\n ///\n /// [1]: https://drafts.csswg.org/css-color/#rgb-to-lab\n /// [2]: https://drafts.csswg.org/css-color/#color-conversion-code\n fn from_xyz(from: &ColorComponents) -> ColorComponents {\n let adapted = *from / Self::WHITE_POINT.values();\n\n // 4. Convert D50-adapted XYZ to Lab.\n let ColorComponents(f0, f1, f2) = adapted.map(|v| {\n if v > Self::EPSILON {\n v.cbrt()\n } else {\n (Self::KAPPA * v + 16.0) / 116.0\n }\n });\n\n let lightness = 116.0 * f1 - 16.0;\n let a = 500.0 * (f0 - f1);\n let b = 200.0 * (f1 - f2);\n\n ColorComponents(lightness, a, b)\n }\n\n fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {\n // No need for conversion.\n from.clone()\n }\n}\n\n/// The Lch color space.\n/// https://drafts.csswg.org/css-color-4/#specifying-lab-lch\npub struct Lch;\n\nimpl ColorSpaceConversion for Lch {\n const WHITE_POINT: WhitePoint = Lab::WHITE_POINT;\n\n fn to_linear_light(from: &ColorComponents) -> ColorComponents {\n // No need for conversion.\n from.clone()\n }\n\n fn to_xyz(from: &ColorComponents) -> ColorComponents {\n // Convert LCH to Lab first.\n let lab = polar_to_orthogonal(from);\n\n // Then convert the Lab to XYZ.\n Lab::to_xyz(&lab)\n }\n\n fn from_xyz(from: &ColorComponents) -> ColorComponents {\n // First convert the XYZ to LAB.\n let lab = Lab::from_xyz(&from);\n\n // Then convert the Lab to LCH.\n orthogonal_to_polar(&lab, epsilon_for_range(0.0, 100.0))\n }\n\n fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {\n // No need for conversion.\n from.clone()\n }\n}\n\n/// The Oklab color space.\n/// https://drafts.csswg.org/css-color-4/#specifying-oklab-oklch\npub struct Oklab;\n\nimpl Oklab {\n #[rustfmt::skip]\n const XYZ_TO_LMS: Transform = Transform::new(\n 0.8190224432164319, 0.0329836671980271, 0.048177199566046255, 0.0,\n 0.3619062562801221, 0.9292868468965546, 0.26423952494422764, 0.0,\n -0.12887378261216414, 0.03614466816999844, 0.6335478258136937, 0.0,\n 0.0, 0.0, 0.0, 1.0,\n );\n\n #[rustfmt::skip]\n const LMS_TO_OKLAB: Transform = Transform::new(\n 0.2104542553, 1.9779984951, 0.0259040371, 0.0,\n 0.7936177850, -2.4285922050, 0.7827717662, 0.0,\n -0.0040720468, 0.4505937099, -0.8086757660, 0.0,\n 0.0, 0.0, 0.0, 1.0,\n );\n\n #[rustfmt::skip]\n const LMS_TO_XYZ: Transform = Transform::new(\n 1.2268798733741557, -0.04057576262431372, -0.07637294974672142, 0.0,\n -0.5578149965554813, 1.1122868293970594, -0.4214933239627914, 0.0,\n 0.28139105017721583, -0.07171106666151701, 1.5869240244272418, 0.0,\n 0.0, 0.0, 0.0, 1.0,\n );\n\n #[rustfmt::skip]\n const OKLAB_TO_LMS: Transform = Transform::new(\n 0.99999999845051981432, 1.0000000088817607767, 1.0000000546724109177, 0.0,\n 0.39633779217376785678, -0.1055613423236563494, -0.089484182094965759684, 0.0,\n 0.21580375806075880339, -0.063854174771705903402, -1.2914855378640917399, 0.0,\n 0.0, 0.0, 0.0, 1.0,\n );\n}\n\nimpl ColorSpaceConversion for Oklab {\n const WHITE_POINT: WhitePoint = WhitePoint::D65;\n\n fn to_linear_light(from: &ColorComponents) -> ColorComponents {\n // No need for conversion.\n from.clone()\n }\n\n fn to_xyz(from: &ColorComponents) -> ColorComponents {\n let lms = transform(&from, &Self::OKLAB_TO_LMS);\n let lms = lms.map(|v| v * v * v);\n transform(&lms, &Self::LMS_TO_XYZ)\n }\n\n fn from_xyz(from: &ColorComponents) -> ColorComponents {\n let lms = transform(&from, &Self::XYZ_TO_LMS);\n let lms = lms.map(|v| v.cbrt());\n transform(&lms, &Self::LMS_TO_OKLAB)\n }\n\n fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {\n // No need for conversion.\n from.clone()\n }\n}\n\n/// The Oklch color space.\n/// https://drafts.csswg.org/css-color-4/#specifying-oklab-oklch\npub struct Oklch;\n\nimpl ColorSpaceConversion for Oklch {\n const WHITE_POINT: WhitePoint = Oklab::WHITE_POINT;\n\n fn to_linear_light(from: &ColorComponents) -> ColorComponents {\n // No need for conversion.\n from.clone()\n }\n\n fn to_xyz(from: &ColorComponents) -> ColorComponents {\n // First convert OkLCH to Oklab.\n let oklab = polar_to_orthogonal(from);\n\n // Then convert Oklab to XYZ.\n Oklab::to_xyz(&oklab)\n }\n\n fn from_xyz(from: &ColorComponents) -> ColorComponents {\n // First convert XYZ to Oklab.\n let lab = Oklab::from_xyz(&from);\n\n // Then convert Oklab to OkLCH.\n orthogonal_to_polar(&lab, epsilon_for_range(0.0, 1.0))\n }\n\n fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {\n // No need for conversion.\n from.clone()\n }\n}\n" }, { "path": "style/color/mix.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! Color mixing/interpolation.\n\nuse super::{AbsoluteColor, ColorFlags, ColorSpace};\nuse crate::color::ColorMixItemList;\nuse crate::derives::*;\nuse crate::parser::{Parse, ParserContext};\nuse crate::values::generics::color::ColorMixFlags;\nuse cssparser::Parser;\nuse std::fmt::{self, Write};\nuse style_traits::{CssWriter, ParseError, ToCss};\n\n/// A hue-interpolation-method as defined in [1].\n///\n/// [1]: https://drafts.csswg.org/css-color-4/#typedef-hue-interpolation-method\n#[derive(\n Clone,\n Copy,\n Debug,\n Eq,\n MallocSizeOf,\n Parse,\n PartialEq,\n ToAnimatedValue,\n ToComputedValue,\n ToCss,\n ToResolvedValue,\n ToShmem,\n)]\n#[repr(u8)]\npub enum HueInterpolationMethod {\n /// https://drafts.csswg.org/css-color-4/#shorter\n Shorter,\n /// https://drafts.csswg.org/css-color-4/#longer\n Longer,\n /// https://drafts.csswg.org/css-color-4/#increasing\n Increasing,\n /// https://drafts.csswg.org/css-color-4/#decreasing\n Decreasing,\n /// https://drafts.csswg.org/css-color-4/#specified\n Specified,\n}\n\n/// https://drafts.csswg.org/css-color-4/#color-interpolation-method\n#[derive(\n Clone,\n Copy,\n Debug,\n Eq,\n MallocSizeOf,\n PartialEq,\n ToShmem,\n ToAnimatedValue,\n ToComputedValue,\n ToResolvedValue,\n)]\n#[repr(C)]\npub struct ColorInterpolationMethod {\n /// The color-space the interpolation should be done in.\n pub space: ColorSpace,\n /// The hue interpolation method.\n pub hue: HueInterpolationMethod,\n}\n\nimpl ColorInterpolationMethod {\n /// Returns the srgb interpolation method.\n pub const fn srgb() -> Self {\n Self {\n space: ColorSpace::Srgb,\n hue: HueInterpolationMethod::Shorter,\n }\n }\n\n /// Return the oklab interpolation method used for default color\n /// interpolcation.\n pub const fn oklab() -> Self {\n Self {\n space: ColorSpace::Oklab,\n hue: HueInterpolationMethod::Shorter,\n }\n }\n\n /// Return true if the this is the default method.\n pub fn is_default(&self) -> bool {\n self.space == ColorSpace::Oklab\n }\n\n /// Decides the best method for interpolating between the given colors.\n /// https://drafts.csswg.org/css-color-4/#interpolation-space\n pub fn best_interpolation_between(left: &AbsoluteColor, right: &AbsoluteColor) -> Self {\n // The default color space to use for interpolation is Oklab. However,\n // if either of the colors are in legacy rgb(), hsl() or hwb(), then\n // interpolation is done in sRGB.\n if !left.is_legacy_syntax() || !right.is_legacy_syntax() {\n Self::default()\n } else {\n Self::srgb()\n }\n }\n}\n\nimpl Default for ColorInterpolationMethod {\n fn default() -> Self {\n Self::oklab()\n }\n}\n\nimpl Parse for ColorInterpolationMethod {\n fn parse<'i, 't>(\n _: &ParserContext,\n input: &mut Parser<'i, 't>,\n ) -> Result> {\n input.expect_ident_matching(\"in\")?;\n let space = ColorSpace::parse(input)?;\n // https://drafts.csswg.org/css-color-4/#hue-interpolation\n // Unless otherwise specified, if no specific hue interpolation\n // algorithm is selected by the host syntax, the default is shorter.\n let hue = if space.is_polar() {\n input\n .try_parse(|input| -> Result<_, ParseError<'i>> {\n let hue = HueInterpolationMethod::parse(input)?;\n input.expect_ident_matching(\"hue\")?;\n Ok(hue)\n })\n .unwrap_or(HueInterpolationMethod::Shorter)\n } else {\n HueInterpolationMethod::Shorter\n };\n Ok(Self { space, hue })\n }\n}\n\nimpl ToCss for ColorInterpolationMethod {\n fn to_css(&self, dest: &mut CssWriter) -> fmt::Result\n where\n W: Write,\n {\n dest.write_str(\"in \")?;\n self.space.to_css(dest)?;\n if self.hue != HueInterpolationMethod::Shorter {\n dest.write_char(' ')?;\n self.hue.to_css(dest)?;\n dest.write_str(\" hue\")?;\n }\n Ok(())\n }\n}\n\n/// A color and its weight for use in a color mix.\npub struct ColorMixItem {\n /// The color being mixed.\n pub color: AbsoluteColor,\n /// How much this color contributes to the final mix.\n pub weight: f32,\n}\n\nimpl ColorMixItem {\n /// Create a new color item for mixing.\n #[inline]\n pub fn new(color: AbsoluteColor, weight: f32) -> Self {\n Self { color, weight }\n }\n}\n\n/// Mix N colors into one (left-to-right fold).\npub fn mix_many(\n interpolation: ColorInterpolationMethod,\n items: impl IntoIterator,\n flags: ColorMixFlags,\n) -> AbsoluteColor {\n let items = items.into_iter().collect::>();\n\n // Match the behavior when the sum of weights equal 0.\n if items.is_empty() {\n return AbsoluteColor::TRANSPARENT_BLACK.to_color_space(interpolation.space);\n }\n\n let normalize = flags.contains(ColorMixFlags::NORMALIZE_WEIGHTS);\n let mut weight_scale = 1.0;\n let mut alpha_multiplier = 1.0;\n if normalize {\n // https://drafts.csswg.org/css-color-5/#color-mix-percent-norm\n let sum: f32 = items.iter().map(|item| item.weight).sum();\n if sum == 0.0 {\n return AbsoluteColor::TRANSPARENT_BLACK.to_color_space(interpolation.space);\n }\n if (sum - 1.0).abs() > f32::EPSILON {\n weight_scale = 1.0 / sum;\n if sum < 1.0 {\n alpha_multiplier = sum;\n }\n }\n }\n\n // We can unwrap here, because we already checked for no items.\n let (first, rest) = items.split_first().unwrap();\n let mut accumulated_color = convert_for_mix(&first.color, interpolation.space);\n let mut accumulated_weight = first.weight * weight_scale;\n\n for item in rest {\n let weight = item.weight * weight_scale;\n let combined = accumulated_weight + weight;\n if combined == 0.0 {\n // If both are 0, this fold doesn't contribute anything to the result.\n continue;\n }\n let right = convert_for_mix(&item.color, interpolation.space);\n\n let (left_weight, right_weight) = if normalize {\n (accumulated_weight / combined, weight / combined)\n } else {\n (accumulated_weight, weight)\n };\n\n accumulated_color = mix_with_weights(\n &accumulated_color,\n left_weight,\n &right,\n right_weight,\n interpolation.hue,\n );\n accumulated_weight = combined;\n }\n\n let components = accumulated_color.raw_components();\n let alpha = components[3] * alpha_multiplier;\n\n // FIXME: In rare cases we end up with 0.999995 in the alpha channel,\n // so we reduce the precision to avoid serializing to\n // rgba(?, ?, ?, 1). This is not ideal, so we should look into\n // ways to avoid it. Maybe pre-multiply all color components and\n // then divide after calculations?\n let alpha = (alpha.clamp(0.0, 1.0) * 1000.0).round() / 1000.0;\n\n let mut result = AbsoluteColor::new(\n interpolation.space,\n components[0],\n components[1],\n components[2],\n alpha,\n );\n result.flags = accumulated_color.flags;\n\n if flags.contains(ColorMixFlags::RESULT_IN_MODERN_SYNTAX) {\n // If the result *MUST* be in modern syntax, then make sure it is in a\n // color space that allows the modern syntax. So hsl and hwb will be\n // converted to srgb.\n if result.is_legacy_syntax() {\n result.to_color_space(ColorSpace::Srgb)\n } else {\n result\n }\n } else if items.iter().all(|item| item.color.is_legacy_syntax()) {\n // If both sides of the mix is legacy then convert the result back into\n // legacy.\n result.into_srgb_legacy()\n } else {\n result\n }\n}\n\n/// What the outcome of each component should be in a mix result.\n#[derive(Clone, Copy, PartialEq)]\n#[repr(u8)]\nenum ComponentMixOutcome {\n /// Mix the left and right sides to give the result.\n Mix,\n /// Carry the left side forward to the result.\n UseLeft,\n /// Carry the right side forward to the result.\n UseRight,\n /// The resulting component should also be none.\n None,\n}\n\nimpl ComponentMixOutcome {\n fn from_colors(\n left: &AbsoluteColor,\n right: &AbsoluteColor,\n flags_to_check: ColorFlags,\n ) -> Self {\n match (\n left.flags.contains(flags_to_check),\n right.flags.contains(flags_to_check),\n ) {\n (true, true) => Self::None,\n (true, false) => Self::UseRight,\n (false, true) => Self::UseLeft,\n (false, false) => Self::Mix,\n }\n }\n}\n\nimpl AbsoluteColor {\n /// Calculate the flags that should be carried forward a color before converting\n /// it to the interpolation color space according to:\n /// \n fn carry_forward_analogous_missing_components(&mut self, source: &AbsoluteColor) {\n use ColorFlags as F;\n use ColorSpace as S;\n\n if source.color_space == self.color_space {\n return;\n }\n\n // Reds r, x\n // Greens g, y\n // Blues b, z\n if source.color_space.is_rgb_or_xyz_like() && self.color_space.is_rgb_or_xyz_like() {\n return;\n }\n\n // Lightness L\n if matches!(source.color_space, S::Lab | S::Lch | S::Oklab | S::Oklch) {\n if matches!(self.color_space, S::Lab | S::Lch | S::Oklab | S::Oklch) {\n self.flags |= source.flags & F::C0_IS_NONE;\n } else if matches!(self.color_space, S::Hsl) {\n if source.flags.contains(F::C0_IS_NONE) {\n self.flags.insert(F::C2_IS_NONE)\n }\n }\n } else if matches!(source.color_space, S::Hsl)\n && matches!(self.color_space, S::Lab | S::Lch | S::Oklab | S::Oklch)\n {\n if source.flags.contains(F::C2_IS_NONE) {\n self.flags.insert(F::C0_IS_NONE)\n }\n }\n\n // Colorfulness C, S\n if matches!(source.color_space, S::Hsl | S::Lch | S::Oklch)\n && matches!(self.color_space, S::Hsl | S::Lch | S::Oklch)\n {\n self.flags |= source.flags & F::C1_IS_NONE;\n }\n\n // Hue H\n if matches!(source.color_space, S::Hsl | S::Hwb) {\n if matches!(self.color_space, S::Hsl | S::Hwb) {\n self.flags |= source.flags & F::C0_IS_NONE;\n } else if matches!(self.color_space, S::Lch | S::Oklch) {\n if source.flags.contains(F::C0_IS_NONE) {\n self.flags.insert(F::C2_IS_NONE)\n }\n }\n } else if matches!(source.color_space, S::Lch | S::Oklch) {\n if matches!(self.color_space, S::Hsl | S::Hwb) {\n if source.flags.contains(F::C2_IS_NONE) {\n self.flags.insert(F::C0_IS_NONE)\n }\n } else if matches!(self.color_space, S::Lch | S::Oklch) {\n self.flags |= source.flags & F::C2_IS_NONE;\n }\n }\n\n // Opponent a, a\n // Opponent b, b\n if matches!(source.color_space, S::Lab | S::Oklab)\n && matches!(self.color_space, S::Lab | S::Oklab)\n {\n self.flags |= source.flags & F::C1_IS_NONE;\n self.flags |= source.flags & F::C2_IS_NONE;\n }\n }\n}\n\n/// Mix two colors already in the interpolation color space.\nfn mix_with_weights(\n left: &AbsoluteColor,\n left_weight: f32,\n right: &AbsoluteColor,\n right_weight: f32,\n hue_interpolation: HueInterpolationMethod,\n) -> AbsoluteColor {\n debug_assert!(right.color_space == left.color_space);\n let color_space = left.color_space;\n\n let outcomes = [\n ComponentMixOutcome::from_colors(&left, &right, ColorFlags::C0_IS_NONE),\n ComponentMixOutcome::from_colors(&left, &right, ColorFlags::C1_IS_NONE),\n ComponentMixOutcome::from_colors(&left, &right, ColorFlags::C2_IS_NONE),\n ComponentMixOutcome::from_colors(&left, &right, ColorFlags::ALPHA_IS_NONE),\n ];\n\n // Convert both sides into just components.\n let left = left.raw_components();\n let right = right.raw_components();\n\n let (result, result_flags) = interpolate_premultiplied(\n &left,\n left_weight,\n &right,\n right_weight,\n color_space.hue_index(),\n hue_interpolation,\n &outcomes,\n );\n\n let mut result = AbsoluteColor::new(color_space, result[0], result[1], result[2], result[3]);\n result.flags = result_flags;\n result\n}\n\nfn convert_for_mix(color: &AbsoluteColor, color_space: ColorSpace) -> AbsoluteColor {\n let mut converted = color.to_color_space(color_space);\n converted.carry_forward_analogous_missing_components(color);\n converted\n}\n\nfn interpolate_premultiplied_component(\n left: f32,\n left_weight: f32,\n left_alpha: f32,\n right: f32,\n right_weight: f32,\n right_alpha: f32,\n) -> f32 {\n left * left_weight * left_alpha + right * right_weight * right_alpha\n}\n\n// Normalize hue into [0, 360)\n#[inline]\nfn normalize_hue(v: f32) -> f32 {\n v - 360. * (v / 360.).floor()\n}\n\nfn adjust_hue(left: &mut f32, right: &mut f32, hue_interpolation: HueInterpolationMethod) {\n // Adjust the hue angle as per\n // https://drafts.csswg.org/css-color/#hue-interpolation.\n //\n // If both hue angles are NAN, they should be set to 0. Otherwise, if a\n // single hue angle is NAN, it should use the other hue angle.\n if left.is_nan() {\n if right.is_nan() {\n *left = 0.;\n *right = 0.;\n } else {\n *left = *right;\n }\n } else if right.is_nan() {\n *right = *left;\n }\n\n if hue_interpolation == HueInterpolationMethod::Specified {\n // Angles are not adjusted. They are interpolated like any other\n // component.\n return;\n }\n\n *left = normalize_hue(*left);\n *right = normalize_hue(*right);\n\n match hue_interpolation {\n // https://drafts.csswg.org/css-color/#shorter\n HueInterpolationMethod::Shorter => {\n let delta = *right - *left;\n\n if delta > 180. {\n *left += 360.;\n } else if delta < -180. {\n *right += 360.;\n }\n },\n // https://drafts.csswg.org/css-color/#longer\n HueInterpolationMethod::Longer => {\n let delta = *right - *left;\n if 0. < delta && delta < 180. {\n *left += 360.;\n } else if -180. < delta && delta <= 0. {\n *right += 360.;\n }\n },\n // https://drafts.csswg.org/css-color/#increasing\n HueInterpolationMethod::Increasing => {\n if *right < *left {\n *right += 360.;\n }\n },\n // https://drafts.csswg.org/css-color/#decreasing\n HueInterpolationMethod::Decreasing => {\n if *left < *right {\n *left += 360.;\n }\n },\n HueInterpolationMethod::Specified => unreachable!(\"Handled above\"),\n }\n}\n\nfn interpolate_hue(\n mut left: f32,\n left_weight: f32,\n mut right: f32,\n right_weight: f32,\n hue_interpolation: HueInterpolationMethod,\n) -> f32 {\n adjust_hue(&mut left, &mut right, hue_interpolation);\n left * left_weight + right * right_weight\n}\n\nstruct InterpolatedAlpha {\n /// The adjusted left alpha value.\n left: f32,\n /// The adjusted right alpha value.\n right: f32,\n /// The interpolated alpha value.\n interpolated: f32,\n /// Whether the alpha component should be `none`.\n is_none: bool,\n}\n\nfn interpolate_alpha(\n left: f32,\n left_weight: f32,\n right: f32,\n right_weight: f32,\n outcome: ComponentMixOutcome,\n) -> InterpolatedAlpha {\n // \n let mut result = match outcome {\n ComponentMixOutcome::Mix => {\n let interpolated = left * left_weight + right * right_weight;\n InterpolatedAlpha {\n left,\n right,\n interpolated,\n is_none: false,\n }\n },\n ComponentMixOutcome::UseLeft => InterpolatedAlpha {\n left,\n right: left,\n interpolated: left,\n is_none: false,\n },\n ComponentMixOutcome::UseRight => InterpolatedAlpha {\n left: right,\n right,\n interpolated: right,\n is_none: false,\n },\n ComponentMixOutcome::None => InterpolatedAlpha {\n left: 1.0,\n right: 1.0,\n interpolated: 0.0,\n is_none: true,\n },\n };\n\n // Clip all alpha values to [0.0..1.0].\n result.left = result.left.clamp(0.0, 1.0);\n result.right = result.right.clamp(0.0, 1.0);\n result.interpolated = result.interpolated.clamp(0.0, 1.0);\n\n result\n}\n\nfn interpolate_premultiplied(\n left: &[f32; 4],\n left_weight: f32,\n right: &[f32; 4],\n right_weight: f32,\n hue_index: Option,\n hue_interpolation: HueInterpolationMethod,\n outcomes: &[ComponentMixOutcome; 4],\n) -> ([f32; 4], ColorFlags) {\n let alpha = interpolate_alpha(left[3], left_weight, right[3], right_weight, outcomes[3]);\n let mut flags = if alpha.is_none {\n ColorFlags::ALPHA_IS_NONE\n } else {\n ColorFlags::empty()\n };\n\n let mut result = [0.; 4];\n\n for i in 0..3 {\n match outcomes[i] {\n ComponentMixOutcome::Mix => {\n let is_hue = hue_index == Some(i);\n result[i] = if is_hue {\n normalize_hue(interpolate_hue(\n left[i],\n left_weight,\n right[i],\n right_weight,\n hue_interpolation,\n ))\n } else {\n let interpolated = interpolate_premultiplied_component(\n left[i],\n left_weight,\n alpha.left,\n right[i],\n right_weight,\n alpha.right,\n );\n\n if alpha.interpolated == 0.0 {\n interpolated\n } else {\n interpolated / alpha.interpolated\n }\n };\n },\n ComponentMixOutcome::UseLeft | ComponentMixOutcome::UseRight => {\n let used_component = if outcomes[i] == ComponentMixOutcome::UseLeft {\n left[i]\n } else {\n right[i]\n };\n result[i] = if hue_interpolation == HueInterpolationMethod::Longer\n && hue_index == Some(i)\n {\n // If \"longer hue\" interpolation is required, we have to actually do\n // the computation even if we're using the same value at both ends,\n // so that interpolating from the starting hue back to the same value\n // produces a full cycle, rather than a constant hue.\n normalize_hue(interpolate_hue(\n used_component,\n left_weight,\n used_component,\n right_weight,\n hue_interpolation,\n ))\n } else {\n used_component\n };\n },\n ComponentMixOutcome::None => {\n result[i] = 0.0;\n match i {\n 0 => flags.insert(ColorFlags::C0_IS_NONE),\n 1 => flags.insert(ColorFlags::C1_IS_NONE),\n 2 => flags.insert(ColorFlags::C2_IS_NONE),\n _ => unreachable!(),\n }\n },\n }\n }\n result[3] = alpha.interpolated;\n\n (result, flags)\n}\n" }, { "path": "style/color/mod.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! Color support functions.\n\n/// cbindgen:ignore\npub mod convert;\n\nmod color_function;\npub mod component;\npub mod mix;\npub mod parsing;\nmod to_css;\n\nuse self::parsing::ChannelKeyword;\nuse crate::derives::*;\npub use color_function::*;\nuse component::ColorComponent;\nuse cssparser::color::PredefinedColorSpace;\n\n/// Number of color-mix items to reserve on the stack to avoid heap allocations.\npub const PRE_ALLOCATED_COLOR_MIX_ITEMS: usize = 3;\n\n/// Conveniece type to use for collecting color mix items.\npub type ColorMixItemList = smallvec::SmallVec<[T; PRE_ALLOCATED_COLOR_MIX_ITEMS]>;\n\n/// The 3 components that make up a color. (Does not include the alpha component)\n#[derive(Copy, Clone, Debug, MallocSizeOf, PartialEq, ToShmem)]\n#[cfg_attr(feature = \"servo\", derive(Deserialize, Serialize))]\n#[repr(C)]\npub struct ColorComponents(pub f32, pub f32, pub f32);\n\nimpl ColorComponents {\n /// Apply a function to each of the 3 components of the color.\n #[must_use]\n pub fn map(self, f: impl Fn(f32) -> f32) -> Self {\n Self(f(self.0), f(self.1), f(self.2))\n }\n}\n\nimpl std::ops::Mul for ColorComponents {\n type Output = Self;\n\n fn mul(self, rhs: Self) -> Self::Output {\n Self(self.0 * rhs.0, self.1 * rhs.1, self.2 * rhs.2)\n }\n}\n\nimpl std::ops::Div for ColorComponents {\n type Output = Self;\n\n fn div(self, rhs: Self) -> Self::Output {\n Self(self.0 / rhs.0, self.1 / rhs.1, self.2 / rhs.2)\n }\n}\n\n/// A color space representation in the CSS specification.\n///\n/// https://drafts.csswg.org/css-color-4/#typedef-color-space\n#[derive(\n Clone,\n Copy,\n Debug,\n Eq,\n MallocSizeOf,\n Parse,\n PartialEq,\n ToAnimatedValue,\n ToComputedValue,\n ToCss,\n ToResolvedValue,\n ToShmem,\n)]\n#[cfg_attr(feature = \"servo\", derive(Deserialize, Serialize))]\n#[repr(u8)]\npub enum ColorSpace {\n /// A color specified in the sRGB color space with either the rgb/rgba(..)\n /// functions or the newer color(srgb ..) function. If the color(..)\n /// function is used, the AS_COLOR_FUNCTION flag will be set. Examples:\n /// \"color(srgb 0.691 0.139 0.259)\", \"rgb(176, 35, 66)\"\n Srgb = 0,\n /// A color specified in the Hsl notation in the sRGB color space, e.g.\n /// \"hsl(289.18 93.136% 65.531%)\"\n /// https://drafts.csswg.org/css-color-4/#the-hsl-notation\n Hsl,\n /// A color specified in the Hwb notation in the sRGB color space, e.g.\n /// \"hwb(740deg 20% 30%)\"\n /// https://drafts.csswg.org/css-color-4/#the-hwb-notation\n Hwb,\n /// A color specified in the Lab color format, e.g.\n /// \"lab(29.2345% 39.3825 20.0664)\".\n /// https://w3c.github.io/csswg-drafts/css-color-4/#lab-colors\n Lab,\n /// A color specified in the Lch color format, e.g.\n /// \"lch(29.2345% 44.2 27)\".\n /// https://w3c.github.io/csswg-drafts/css-color-4/#lch-colors\n Lch,\n /// A color specified in the Oklab color format, e.g.\n /// \"oklab(40.101% 0.1147 0.0453)\".\n /// https://w3c.github.io/csswg-drafts/css-color-4/#lab-colors\n Oklab,\n /// A color specified in the Oklch color format, e.g.\n /// \"oklch(40.101% 0.12332 21.555)\".\n /// https://w3c.github.io/csswg-drafts/css-color-4/#lch-colors\n Oklch,\n /// A color specified with the color(..) function and the \"srgb-linear\"\n /// color space, e.g. \"color(srgb-linear 0.435 0.017 0.055)\".\n SrgbLinear,\n /// A color specified with the color(..) function and the \"display-p3\"\n /// color space, e.g. \"color(display-p3 0.84 0.19 0.72)\".\n DisplayP3,\n /// A color specified with the color(..) function and the \"display-p3-linear\"\n /// color space.\n DisplayP3Linear,\n /// A color specified with the color(..) function and the \"a98-rgb\" color\n /// space, e.g. \"color(a98-rgb 0.44091 0.49971 0.37408)\".\n A98Rgb,\n /// A color specified with the color(..) function and the \"prophoto-rgb\"\n /// color space, e.g. \"color(prophoto-rgb 0.36589 0.41717 0.31333)\".\n ProphotoRgb,\n /// A color specified with the color(..) function and the \"rec2020\" color\n /// space, e.g. \"color(rec2020 0.42210 0.47580 0.35605)\".\n Rec2020,\n /// A color specified with the color(..) function and the \"xyz-d50\" color\n /// space, e.g. \"color(xyz-d50 0.2005 0.14089 0.4472)\".\n XyzD50,\n /// A color specified with the color(..) function and the \"xyz-d65\" or \"xyz\"\n /// color space, e.g. \"color(xyz-d65 0.21661 0.14602 0.59452)\".\n /// NOTE: https://drafts.csswg.org/css-color-4/#resolving-color-function-values\n /// specifies that `xyz` is an alias for the `xyz-d65` color space.\n #[parse(aliases = \"xyz\")]\n XyzD65,\n}\n\nimpl ColorSpace {\n /// Returns whether this is a ``.\n #[inline]\n pub fn is_rectangular(&self) -> bool {\n !self.is_polar()\n }\n\n /// Returns whether this is a ``.\n #[inline]\n pub fn is_polar(&self) -> bool {\n matches!(self, Self::Hsl | Self::Hwb | Self::Lch | Self::Oklch)\n }\n\n /// Returns true if the color has RGB or XYZ components.\n #[inline]\n pub fn is_rgb_or_xyz_like(&self) -> bool {\n match self {\n Self::Srgb\n | Self::SrgbLinear\n | Self::DisplayP3\n | Self::DisplayP3Linear\n | Self::A98Rgb\n | Self::ProphotoRgb\n | Self::Rec2020\n | Self::XyzD50\n | Self::XyzD65 => true,\n _ => false,\n }\n }\n\n /// Returns an index of the hue component in the color space, otherwise\n /// `None`.\n #[inline]\n pub fn hue_index(&self) -> Option {\n match self {\n Self::Hsl | Self::Hwb => Some(0),\n Self::Lch | Self::Oklch => Some(2),\n\n _ => {\n debug_assert!(!self.is_polar());\n None\n },\n }\n }\n}\n\n/// Flags used when serializing colors.\n#[derive(Clone, Copy, Debug, Default, MallocSizeOf, PartialEq, ToShmem)]\n#[cfg_attr(feature = \"serde\", derive(Deserialize, Serialize))]\n#[repr(C)]\npub struct ColorFlags(u8);\nbitflags! {\n impl ColorFlags : u8 {\n /// Whether the 1st color component is `none`.\n const C0_IS_NONE = 1 << 0;\n /// Whether the 2nd color component is `none`.\n const C1_IS_NONE = 1 << 1;\n /// Whether the 3rd color component is `none`.\n const C2_IS_NONE = 1 << 2;\n /// Whether the alpha component is `none`.\n const ALPHA_IS_NONE = 1 << 3;\n /// Marks that this color is in the legacy color format. This flag is\n /// only valid for the `Srgb` color space.\n const IS_LEGACY_SRGB = 1 << 4;\n }\n}\n\n/// An absolutely specified color, using either rgb(), rgba(), lab(), lch(),\n/// oklab(), oklch() or color().\n#[derive(Copy, Clone, Debug, MallocSizeOf, ToShmem, ToTyped)]\n#[cfg_attr(feature = \"servo\", derive(Deserialize, Serialize))]\n#[repr(C)]\n#[typed(todo_derive_fields)]\npub struct AbsoluteColor {\n /// The 3 components that make up colors in any color space.\n pub components: ColorComponents,\n /// The alpha component of the color.\n pub alpha: f32,\n /// The current color space that the components represent.\n pub color_space: ColorSpace,\n /// Extra flags used during serialization of this color.\n pub flags: ColorFlags,\n}\n\nimpl PartialEq for AbsoluteColor {\n // See https://github.com/w3c/csswg-drafts/issues/13157#issuecomment-4165667681\n fn eq(&self, other: &Self) -> bool {\n let none_flags = ColorFlags::C0_IS_NONE\n | ColorFlags::C1_IS_NONE\n | ColorFlags::C2_IS_NONE\n | ColorFlags::ALPHA_IS_NONE;\n // If both colors have the same color-space, just compare components; note that\n // any `none` components only match `none` in the other color.\n if self.color_space == other.color_space {\n return self.components == other.components\n && self.alpha == other.alpha\n && (self.flags & none_flags) == (other.flags & none_flags);\n }\n // Otherwise, if any `none` components are present in either color, return false.\n if self.flags.union(other.flags).intersects(none_flags) {\n return false;\n }\n // Otherwise, convert both colors to Oklab for comparison, and allow EPSILON\n // difference in component values.\n // TODO: check value of EPSILON once the spec is updated to cover this.\n const EPSILON: f32 = 0.0001;\n let a = self.to_color_space(ColorSpace::Oklab);\n let b = other.to_color_space(ColorSpace::Oklab);\n (a.components.0 - b.components.0).abs() <= EPSILON\n && (a.components.1 - b.components.1).abs() <= EPSILON\n && (a.components.2 - b.components.2).abs() <= EPSILON\n && (a.alpha - b.alpha).abs() <= EPSILON\n }\n}\n\n/// Given an [`AbsoluteColor`], return the 4 float components as the type given,\n/// e.g.:\n///\n/// ```rust\n/// let srgb = AbsoluteColor::new(ColorSpace::Srgb, 1.0, 0.0, 0.0, 0.0);\n/// let floats = color_components_as!(&srgb, [f32; 4]); // [1.0, 0.0, 0.0, 0.0]\n/// ```\nmacro_rules! color_components_as {\n ($c:expr, $t:ty) => {{\n // This macro is not an inline function, because we can't use the\n // generic type ($t) in a constant expression as per:\n // https://github.com/rust-lang/rust/issues/76560\n const_assert_eq!(std::mem::size_of::<$t>(), std::mem::size_of::<[f32; 4]>());\n const_assert_eq!(std::mem::align_of::<$t>(), std::mem::align_of::<[f32; 4]>());\n const_assert!(std::mem::size_of::() >= std::mem::size_of::<$t>());\n const_assert_eq!(\n std::mem::align_of::(),\n std::mem::align_of::<$t>()\n );\n\n std::mem::transmute::<&ColorComponents, &$t>(&$c.components)\n }};\n}\n\n/// Holds details about each component passed into creating a new [`AbsoluteColor`].\npub struct ComponentDetails {\n value: f32,\n is_none: bool,\n}\n\nimpl From for ComponentDetails {\n fn from(value: f32) -> Self {\n Self {\n value,\n is_none: false,\n }\n }\n}\n\nimpl From for ComponentDetails {\n fn from(value: u8) -> Self {\n Self {\n value: value as f32 / 255.0,\n is_none: false,\n }\n }\n}\n\nimpl From> for ComponentDetails {\n fn from(value: Option) -> Self {\n if let Some(value) = value {\n Self {\n value,\n is_none: false,\n }\n } else {\n Self {\n value: 0.0,\n is_none: true,\n }\n }\n }\n}\n\nimpl From> for ComponentDetails {\n fn from(value: ColorComponent) -> Self {\n if let ColorComponent::Value(value) = value {\n Self {\n value,\n is_none: false,\n }\n } else {\n Self {\n value: 0.0,\n is_none: true,\n }\n }\n }\n}\n\nimpl AbsoluteColor {\n /// A fully transparent color in the legacy syntax.\n pub const TRANSPARENT_BLACK: Self = Self {\n components: ColorComponents(0.0, 0.0, 0.0),\n alpha: 0.0,\n color_space: ColorSpace::Srgb,\n flags: ColorFlags::IS_LEGACY_SRGB,\n };\n\n /// An opaque black color in the legacy syntax.\n pub const BLACK: Self = Self {\n components: ColorComponents(0.0, 0.0, 0.0),\n alpha: 1.0,\n color_space: ColorSpace::Srgb,\n flags: ColorFlags::IS_LEGACY_SRGB,\n };\n\n /// An opaque white color in the legacy syntax.\n pub const WHITE: Self = Self {\n components: ColorComponents(1.0, 1.0, 1.0),\n alpha: 1.0,\n color_space: ColorSpace::Srgb,\n flags: ColorFlags::IS_LEGACY_SRGB,\n };\n\n /// Create a new [`AbsoluteColor`] with the given [`ColorSpace`] and\n /// components.\n pub fn new(\n color_space: ColorSpace,\n c1: impl Into,\n c2: impl Into,\n c3: impl Into,\n alpha: impl Into,\n ) -> Self {\n let mut flags = ColorFlags::empty();\n\n macro_rules! cd {\n ($c:expr,$flag:expr) => {{\n let component_details = $c.into();\n if component_details.is_none {\n flags |= $flag;\n }\n component_details.value\n }};\n }\n\n let mut components = ColorComponents(\n cd!(c1, ColorFlags::C0_IS_NONE),\n cd!(c2, ColorFlags::C1_IS_NONE),\n cd!(c3, ColorFlags::C2_IS_NONE),\n );\n\n let alpha = cd!(alpha, ColorFlags::ALPHA_IS_NONE);\n\n // Lightness for Lab and Lch is clamped to [0..100].\n if matches!(color_space, ColorSpace::Lab | ColorSpace::Lch) {\n components.0 = components.0.clamp(0.0, 100.0);\n }\n\n // Lightness for Oklab and Oklch is clamped to [0..1].\n if matches!(color_space, ColorSpace::Oklab | ColorSpace::Oklch) {\n components.0 = components.0.clamp(0.0, 1.0);\n }\n\n // Chroma must not be less than 0.\n if matches!(color_space, ColorSpace::Lch | ColorSpace::Oklch) {\n components.1 = components.1.max(0.0);\n }\n\n // Alpha is always clamped to [0..1].\n let alpha = alpha.clamp(0.0, 1.0);\n\n Self {\n components,\n alpha,\n color_space,\n flags,\n }\n }\n\n /// Convert this color into the sRGB color space and set it to the legacy\n /// syntax.\n #[inline]\n #[must_use]\n pub fn into_srgb_legacy(self) -> Self {\n let mut result = if !matches!(self.color_space, ColorSpace::Srgb) {\n self.to_color_space(ColorSpace::Srgb)\n } else {\n self\n };\n\n // Explicitly set the flags to IS_LEGACY_SRGB only to clear out the\n // *_IS_NONE flags, because the legacy syntax doesn't allow \"none\".\n result.flags = ColorFlags::IS_LEGACY_SRGB;\n\n result\n }\n\n /// Create a new [`AbsoluteColor`] from rgba legacy syntax values in the sRGB color space.\n pub fn srgb_legacy(red: u8, green: u8, blue: u8, alpha: f32) -> Self {\n let mut result = Self::new(ColorSpace::Srgb, red, green, blue, alpha);\n result.flags = ColorFlags::IS_LEGACY_SRGB;\n result\n }\n\n /// Return all the components of the color in an array. (Includes alpha)\n #[inline]\n pub fn raw_components(&self) -> &[f32; 4] {\n unsafe { color_components_as!(self, [f32; 4]) }\n }\n\n /// Returns true if this color is in the legacy color syntax.\n #[inline]\n pub fn is_legacy_syntax(&self) -> bool {\n // rgb(), rgba(), hsl(), hsla(), hwb(), hwba()\n match self.color_space {\n ColorSpace::Srgb => self.flags.contains(ColorFlags::IS_LEGACY_SRGB),\n ColorSpace::Hsl | ColorSpace::Hwb => true,\n _ => false,\n }\n }\n\n /// Returns true if this color is fully transparent.\n #[inline]\n pub fn is_transparent(&self) -> bool {\n self.flags.contains(ColorFlags::ALPHA_IS_NONE) || self.alpha == 0.0\n }\n\n /// Return an optional first component.\n #[inline]\n pub fn c0(&self) -> Option {\n if self.flags.contains(ColorFlags::C0_IS_NONE) {\n None\n } else {\n Some(self.components.0)\n }\n }\n\n /// Return an optional second component.\n #[inline]\n pub fn c1(&self) -> Option {\n if self.flags.contains(ColorFlags::C1_IS_NONE) {\n None\n } else {\n Some(self.components.1)\n }\n }\n\n /// Return an optional second component.\n #[inline]\n pub fn c2(&self) -> Option {\n if self.flags.contains(ColorFlags::C2_IS_NONE) {\n None\n } else {\n Some(self.components.2)\n }\n }\n\n /// Return an optional alpha component.\n #[inline]\n pub fn alpha(&self) -> Option {\n if self.flags.contains(ColorFlags::ALPHA_IS_NONE) {\n None\n } else {\n Some(self.alpha)\n }\n }\n\n /// Return the value of a component by its channel keyword.\n pub fn get_component_by_channel_keyword(\n &self,\n channel_keyword: ChannelKeyword,\n ) -> Result, ()> {\n if channel_keyword == ChannelKeyword::Alpha {\n return Ok(self.alpha());\n }\n\n Ok(match self.color_space {\n ColorSpace::Srgb => {\n if self.flags.contains(ColorFlags::IS_LEGACY_SRGB) {\n match channel_keyword {\n ChannelKeyword::R => self.c0().map(|v| v * 255.0),\n ChannelKeyword::G => self.c1().map(|v| v * 255.0),\n ChannelKeyword::B => self.c2().map(|v| v * 255.0),\n _ => return Err(()),\n }\n } else {\n match channel_keyword {\n ChannelKeyword::R => self.c0(),\n ChannelKeyword::G => self.c1(),\n ChannelKeyword::B => self.c2(),\n _ => return Err(()),\n }\n }\n },\n ColorSpace::Hsl => match channel_keyword {\n ChannelKeyword::H => self.c0(),\n ChannelKeyword::S => self.c1(),\n ChannelKeyword::L => self.c2(),\n _ => return Err(()),\n },\n ColorSpace::Hwb => match channel_keyword {\n ChannelKeyword::H => self.c0(),\n ChannelKeyword::W => self.c1(),\n ChannelKeyword::B => self.c2(),\n _ => return Err(()),\n },\n ColorSpace::Lab | ColorSpace::Oklab => match channel_keyword {\n ChannelKeyword::L => self.c0(),\n ChannelKeyword::A => self.c1(),\n ChannelKeyword::B => self.c2(),\n _ => return Err(()),\n },\n ColorSpace::Lch | ColorSpace::Oklch => match channel_keyword {\n ChannelKeyword::L => self.c0(),\n ChannelKeyword::C => self.c1(),\n ChannelKeyword::H => self.c2(),\n _ => return Err(()),\n },\n ColorSpace::SrgbLinear\n | ColorSpace::DisplayP3\n | ColorSpace::DisplayP3Linear\n | ColorSpace::A98Rgb\n | ColorSpace::ProphotoRgb\n | ColorSpace::Rec2020 => match channel_keyword {\n ChannelKeyword::R => self.c0(),\n ChannelKeyword::G => self.c1(),\n ChannelKeyword::B => self.c2(),\n _ => return Err(()),\n },\n ColorSpace::XyzD50 | ColorSpace::XyzD65 => match channel_keyword {\n ChannelKeyword::X => self.c0(),\n ChannelKeyword::Y => self.c1(),\n ChannelKeyword::Z => self.c2(),\n _ => return Err(()),\n },\n })\n }\n\n /// Convert this color to the specified color space.\n pub fn to_color_space(&self, color_space: ColorSpace) -> Self {\n use ColorSpace::*;\n\n if self.color_space == color_space {\n return self.clone();\n }\n\n // Conversion functions doesn't handle NAN component values, so they are\n // converted to 0.0. They do however need to know if a component is\n // missing, so we use NAN as the marker for that.\n macro_rules! missing_to_nan {\n ($c:expr) => {{\n if let Some(v) = $c {\n crate::values::normalize(v)\n } else {\n f32::NAN\n }\n }};\n }\n\n let components = ColorComponents(\n missing_to_nan!(self.c0()),\n missing_to_nan!(self.c1()),\n missing_to_nan!(self.c2()),\n );\n\n let result = match (self.color_space, color_space) {\n // We have simplified conversions that do not need to convert to XYZ\n // first. This improves performance, because it skips at least 2\n // matrix multiplications and reduces float rounding errors.\n (Srgb, Hsl) => convert::rgb_to_hsl(&components),\n (Srgb, Hwb) => convert::rgb_to_hwb(&components),\n (Hsl, Srgb) => convert::hsl_to_rgb(&components),\n (Hwb, Srgb) => convert::hwb_to_rgb(&components),\n (Lab, Lch) | (Oklab, Oklch) => convert::orthogonal_to_polar(\n &components,\n convert::epsilon_for_range(0.0, if color_space == Lch { 100.0 } else { 1.0 }),\n ),\n (Lch, Lab) | (Oklch, Oklab) => convert::polar_to_orthogonal(&components),\n\n // All other conversions need to convert to XYZ first.\n _ => {\n let (xyz, white_point) = match self.color_space {\n Lab => convert::to_xyz::(&components),\n Lch => convert::to_xyz::(&components),\n Oklab => convert::to_xyz::(&components),\n Oklch => convert::to_xyz::(&components),\n Srgb => convert::to_xyz::(&components),\n Hsl => convert::to_xyz::(&components),\n Hwb => convert::to_xyz::(&components),\n SrgbLinear => convert::to_xyz::(&components),\n DisplayP3 => convert::to_xyz::(&components),\n DisplayP3Linear => convert::to_xyz::(&components),\n A98Rgb => convert::to_xyz::(&components),\n ProphotoRgb => convert::to_xyz::(&components),\n Rec2020 => convert::to_xyz::(&components),\n XyzD50 => convert::to_xyz::(&components),\n XyzD65 => convert::to_xyz::(&components),\n };\n\n match color_space {\n Lab => convert::from_xyz::(&xyz, white_point),\n Lch => convert::from_xyz::(&xyz, white_point),\n Oklab => convert::from_xyz::(&xyz, white_point),\n Oklch => convert::from_xyz::(&xyz, white_point),\n Srgb => convert::from_xyz::(&xyz, white_point),\n Hsl => convert::from_xyz::(&xyz, white_point),\n Hwb => convert::from_xyz::(&xyz, white_point),\n SrgbLinear => convert::from_xyz::(&xyz, white_point),\n DisplayP3 => convert::from_xyz::(&xyz, white_point),\n DisplayP3Linear => {\n convert::from_xyz::(&xyz, white_point)\n },\n A98Rgb => convert::from_xyz::(&xyz, white_point),\n ProphotoRgb => convert::from_xyz::(&xyz, white_point),\n Rec2020 => convert::from_xyz::(&xyz, white_point),\n XyzD50 => convert::from_xyz::(&xyz, white_point),\n XyzD65 => convert::from_xyz::(&xyz, white_point),\n }\n },\n };\n\n // A NAN value coming from a conversion function means the the component\n // is missing, so we convert it to None.\n macro_rules! nan_to_missing {\n ($v:expr) => {{\n if $v.is_nan() {\n None\n } else {\n Some($v)\n }\n }};\n }\n\n Self::new(\n color_space,\n nan_to_missing!(result.0),\n nan_to_missing!(result.1),\n nan_to_missing!(result.2),\n self.alpha(),\n )\n }\n\n /// Convert a color value to `nscolor`.\n pub fn to_nscolor(&self) -> u32 {\n let srgb = self.to_color_space(ColorSpace::Srgb);\n u32::from_le_bytes([\n (srgb.components.0 * 255.0).round() as u8,\n (srgb.components.1 * 255.0).round() as u8,\n (srgb.components.2 * 255.0).round() as u8,\n (srgb.alpha * 255.0).round() as u8,\n ])\n }\n\n /// Convert a given `nscolor` to a Servo AbsoluteColor value.\n pub fn from_nscolor(color: u32) -> Self {\n let [r, g, b, a] = color.to_le_bytes();\n Self::srgb_legacy(r, g, b, a as f32 / 255.0)\n }\n}\n\n#[test]\nfn from_nscolor_should_be_in_legacy_syntax() {\n let result = AbsoluteColor::from_nscolor(0x336699CC);\n assert!(result.flags.contains(ColorFlags::IS_LEGACY_SRGB));\n assert!(result.is_legacy_syntax());\n}\n\nimpl From for ColorSpace {\n fn from(value: PredefinedColorSpace) -> Self {\n match value {\n PredefinedColorSpace::Srgb => ColorSpace::Srgb,\n PredefinedColorSpace::SrgbLinear => ColorSpace::SrgbLinear,\n PredefinedColorSpace::DisplayP3 => ColorSpace::DisplayP3,\n PredefinedColorSpace::DisplayP3Linear => ColorSpace::DisplayP3Linear,\n PredefinedColorSpace::A98Rgb => ColorSpace::A98Rgb,\n PredefinedColorSpace::ProphotoRgb => ColorSpace::ProphotoRgb,\n PredefinedColorSpace::Rec2020 => ColorSpace::Rec2020,\n PredefinedColorSpace::XyzD50 => ColorSpace::XyzD50,\n PredefinedColorSpace::XyzD65 => ColorSpace::XyzD65,\n }\n }\n}\n" }, { "path": "style/color/parsing.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/. */\n\n#![deny(missing_docs)]\n\n//! Parsing for CSS colors.\n\nuse super::{\n color_function::ColorFunction,\n component::{ColorComponent, ColorComponentType},\n AbsoluteColor,\n};\nuse crate::derives::*;\nuse crate::{\n parser::{Parse, ParserContext},\n values::{\n generics::{calc::CalcUnits, Optional},\n specified::{angle::Angle as SpecifiedAngle, calc::Leaf, color::Color as SpecifiedColor},\n },\n};\nuse cssparser::{\n color::{parse_hash_color, PredefinedColorSpace, OPAQUE},\n match_ignore_ascii_case, CowRcStr, Parser, Token,\n};\nuse style_traits::{ParseError, StyleParseErrorKind};\n\n/// Returns true if the relative color syntax pref is enabled.\n#[inline]\npub fn rcs_enabled() -> bool {\n static_prefs::pref!(\"layout.css.relative-color-syntax.enabled\")\n}\n\n/// Represents a channel keyword inside a color.\n#[derive(Clone, Copy, Debug, MallocSizeOf, Parse, PartialEq, PartialOrd, ToCss, ToShmem)]\n#[repr(u8)]\npub enum ChannelKeyword {\n /// alpha\n Alpha,\n /// a\n A,\n /// b, blackness, blue\n B,\n /// chroma\n C,\n /// green\n G,\n /// hue\n H,\n /// lightness\n L,\n /// red\n R,\n /// saturation\n S,\n /// whiteness\n W,\n /// x\n X,\n /// y\n Y,\n /// z\n Z,\n}\n\n/// Return the named color with the given name.\n///\n/// Matching is case-insensitive in the ASCII range.\n/// CSS escaping (if relevant) should be resolved before calling this function.\n/// (For example, the value of an `Ident` token is fine.)\n#[inline]\npub fn parse_color_keyword(ident: &str) -> Result {\n Ok(match_ignore_ascii_case! { ident,\n \"transparent\" => {\n SpecifiedColor::from_absolute_color(AbsoluteColor::srgb_legacy(0u8, 0u8, 0u8, 0.0))\n },\n \"currentcolor\" => SpecifiedColor::CurrentColor,\n _ => {\n let (r, g, b) = cssparser::color::parse_named_color(ident)?;\n SpecifiedColor::from_absolute_color(AbsoluteColor::srgb_legacy(r, g, b, OPAQUE))\n },\n })\n}\n\n/// Parse a CSS color using the specified [`ColorParser`] and return a new color\n/// value on success.\npub fn parse_color_with<'i, 't>(\n context: &ParserContext,\n input: &mut Parser<'i, 't>,\n) -> Result> {\n let location = input.current_source_location();\n let token = input.next()?;\n match *token {\n Token::Hash(ref value) | Token::IDHash(ref value) => parse_hash_color(value.as_bytes())\n .map(|(r, g, b, a)| {\n SpecifiedColor::from_absolute_color(AbsoluteColor::srgb_legacy(r, g, b, a))\n }),\n Token::Ident(ref value) => parse_color_keyword(value),\n Token::Function(ref name) => {\n let name = name.clone();\n return input.parse_nested_block(|arguments| {\n let color_function = parse_color_function(context, name, arguments)?;\n\n if color_function.has_origin_color() {\n // Preserve the color as it was parsed.\n Ok(SpecifiedColor::ColorFunction(Box::new(color_function)))\n } else if let Ok(resolved) = color_function.resolve_to_absolute() {\n Ok(SpecifiedColor::from_absolute_color(resolved))\n } else {\n // This will only happen when the parsed color contains errors like calc units\n // that cannot be resolved at parse time, but will fail when trying to resolve\n // them, etc. This should be rare, but for now just failing the color value\n // makes sense.\n Err(location.new_custom_error(StyleParseErrorKind::UnspecifiedError))\n }\n });\n },\n _ => Err(()),\n }\n .map_err(|()| location.new_unexpected_token_error(token.clone()))\n}\n\n/// Parse one of the color functions: rgba(), lab(), color(), etc.\n#[inline]\nfn parse_color_function<'i, 't>(\n context: &ParserContext,\n name: CowRcStr<'i>,\n arguments: &mut Parser<'i, 't>,\n) -> Result, ParseError<'i>> {\n let origin_color = parse_origin_color(context, arguments)?;\n let has_origin_color = origin_color.is_some();\n\n let color = match_ignore_ascii_case! { &name,\n \"rgb\" | \"rgba\" => parse_rgb(context, arguments, origin_color),\n \"hsl\" | \"hsla\" => parse_hsl(context, arguments, origin_color),\n \"hwb\" => parse_hwb(context, arguments, origin_color),\n \"lab\" => parse_lab_like(context, arguments, origin_color, ColorFunction::Lab),\n \"lch\" => parse_lch_like(context, arguments, origin_color, ColorFunction::Lch),\n \"oklab\" => parse_lab_like(context, arguments, origin_color, ColorFunction::Oklab),\n \"oklch\" => parse_lch_like(context, arguments, origin_color, ColorFunction::Oklch),\n \"color\" => parse_color_with_color_space(context, arguments, origin_color),\n _ => return Err(arguments.new_unexpected_token_error(Token::Ident(name))),\n }?;\n\n if has_origin_color {\n // Validate the channels and calc expressions by trying to resolve them against\n // transparent.\n // FIXME(emilio, bug 1925572): This could avoid cloning, or be done earlier.\n let abs = color\n .map_origin_color(|_| Ok(AbsoluteColor::TRANSPARENT_BLACK))\n .unwrap();\n if abs.resolve_to_absolute().is_err() {\n return Err(arguments.new_custom_error(StyleParseErrorKind::UnspecifiedError));\n }\n }\n\n arguments.expect_exhausted()?;\n\n Ok(color)\n}\n\n/// Parse the relative color syntax \"from\" syntax `from `.\nfn parse_origin_color<'i, 't>(\n context: &ParserContext,\n arguments: &mut Parser<'i, 't>,\n) -> Result, ParseError<'i>> {\n if !rcs_enabled() {\n return Ok(None);\n }\n\n // Not finding the from keyword is not an error, it just means we don't\n // have an origin color.\n if arguments\n .try_parse(|p| p.expect_ident_matching(\"from\"))\n .is_err()\n {\n return Ok(None);\n }\n\n SpecifiedColor::parse(context, arguments).map(Option::Some)\n}\n\n#[inline]\nfn parse_rgb<'i, 't>(\n context: &ParserContext,\n arguments: &mut Parser<'i, 't>,\n origin_color: Option,\n) -> Result, ParseError<'i>> {\n let maybe_red = parse_number_or_percentage(context, arguments, true)?;\n\n // If the first component is not \"none\" and is followed by a comma, then we\n // are parsing the legacy syntax. Legacy syntax also doesn't support an\n // origin color.\n let is_legacy_syntax = origin_color.is_none()\n && !maybe_red.is_none()\n && arguments.try_parse(|p| p.expect_comma()).is_ok();\n\n Ok(if is_legacy_syntax {\n let (green, blue) = if maybe_red.could_be_percentage() {\n let green = parse_percentage(context, arguments, false)?;\n arguments.expect_comma()?;\n let blue = parse_percentage(context, arguments, false)?;\n (green, blue)\n } else {\n let green = parse_number(context, arguments, false)?;\n arguments.expect_comma()?;\n let blue = parse_number(context, arguments, false)?;\n (green, blue)\n };\n\n let alpha = parse_legacy_alpha(context, arguments)?;\n\n ColorFunction::Rgb(origin_color.into(), maybe_red, green, blue, alpha)\n } else {\n let green = parse_number_or_percentage(context, arguments, true)?;\n let blue = parse_number_or_percentage(context, arguments, true)?;\n\n let alpha = parse_modern_alpha(context, arguments)?;\n\n ColorFunction::Rgb(origin_color.into(), maybe_red, green, blue, alpha)\n })\n}\n\n/// Parses hsl syntax.\n///\n/// \n#[inline]\nfn parse_hsl<'i, 't>(\n context: &ParserContext,\n arguments: &mut Parser<'i, 't>,\n origin_color: Option,\n) -> Result, ParseError<'i>> {\n let hue = parse_number_or_angle(context, arguments, true)?;\n\n // If the hue is not \"none\" and is followed by a comma, then we are parsing\n // the legacy syntax. Legacy syntax also doesn't support an origin color.\n let is_legacy_syntax = origin_color.is_none()\n && !hue.is_none()\n && arguments.try_parse(|p| p.expect_comma()).is_ok();\n\n let (saturation, lightness, alpha) = if is_legacy_syntax {\n let saturation = parse_percentage(context, arguments, false)?;\n arguments.expect_comma()?;\n let lightness = parse_percentage(context, arguments, false)?;\n let alpha = parse_legacy_alpha(context, arguments)?;\n (saturation, lightness, alpha)\n } else {\n let saturation = parse_number_or_percentage(context, arguments, true)?;\n let lightness = parse_number_or_percentage(context, arguments, true)?;\n let alpha = parse_modern_alpha(context, arguments)?;\n (saturation, lightness, alpha)\n };\n\n Ok(ColorFunction::Hsl(\n origin_color.into(),\n hue,\n saturation,\n lightness,\n alpha,\n ))\n}\n\n/// Parses hwb syntax.\n///\n/// \n#[inline]\nfn parse_hwb<'i, 't>(\n context: &ParserContext,\n arguments: &mut Parser<'i, 't>,\n origin_color: Option,\n) -> Result, ParseError<'i>> {\n let hue = parse_number_or_angle(context, arguments, true)?;\n let whiteness = parse_number_or_percentage(context, arguments, true)?;\n let blackness = parse_number_or_percentage(context, arguments, true)?;\n\n let alpha = parse_modern_alpha(context, arguments)?;\n\n Ok(ColorFunction::Hwb(\n origin_color.into(),\n hue,\n whiteness,\n blackness,\n alpha,\n ))\n}\n\ntype IntoLabFn = fn(\n origin: Optional,\n l: ColorComponent,\n a: ColorComponent,\n b: ColorComponent,\n alpha: ColorComponent,\n) -> Output;\n\n#[inline]\nfn parse_lab_like<'i, 't>(\n context: &ParserContext,\n arguments: &mut Parser<'i, 't>,\n origin_color: Option,\n into_color: IntoLabFn>,\n) -> Result, ParseError<'i>> {\n let lightness = parse_number_or_percentage(context, arguments, true)?;\n let a = parse_number_or_percentage(context, arguments, true)?;\n let b = parse_number_or_percentage(context, arguments, true)?;\n\n let alpha = parse_modern_alpha(context, arguments)?;\n\n Ok(into_color(origin_color.into(), lightness, a, b, alpha))\n}\n\ntype IntoLchFn = fn(\n origin: Optional,\n l: ColorComponent,\n a: ColorComponent,\n b: ColorComponent,\n alpha: ColorComponent,\n) -> Output;\n\n#[inline]\nfn parse_lch_like<'i, 't>(\n context: &ParserContext,\n arguments: &mut Parser<'i, 't>,\n origin_color: Option,\n into_color: IntoLchFn>,\n) -> Result, ParseError<'i>> {\n let lightness = parse_number_or_percentage(context, arguments, true)?;\n let chroma = parse_number_or_percentage(context, arguments, true)?;\n let hue = parse_number_or_angle(context, arguments, true)?;\n\n let alpha = parse_modern_alpha(context, arguments)?;\n\n Ok(into_color(\n origin_color.into(),\n lightness,\n chroma,\n hue,\n alpha,\n ))\n}\n\n/// Parse the color() function.\n#[inline]\nfn parse_color_with_color_space<'i, 't>(\n context: &ParserContext,\n arguments: &mut Parser<'i, 't>,\n origin_color: Option,\n) -> Result, ParseError<'i>> {\n let color_space = PredefinedColorSpace::parse(arguments)?;\n\n let c1 = parse_number_or_percentage(context, arguments, true)?;\n let c2 = parse_number_or_percentage(context, arguments, true)?;\n let c3 = parse_number_or_percentage(context, arguments, true)?;\n\n let alpha = parse_modern_alpha(context, arguments)?;\n\n Ok(ColorFunction::Color(\n origin_color.into(),\n c1,\n c2,\n c3,\n alpha,\n color_space.into(),\n ))\n}\n\n/// Either a percentage or a number.\n#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, ToAnimatedValue, ToShmem)]\n#[repr(u8)]\npub enum NumberOrPercentageComponent {\n /// ``.\n Number(f32),\n /// ``\n /// The value as a float, divided by 100 so that the nominal range is 0.0 to 1.0.\n Percentage(f32),\n}\n\nimpl NumberOrPercentageComponent {\n /// Return the value as a number. Percentages will be adjusted to the range\n /// [0..percent_basis].\n pub fn to_number(&self, percentage_basis: f32) -> f32 {\n match *self {\n Self::Number(value) => value,\n Self::Percentage(unit_value) => unit_value * percentage_basis,\n }\n }\n}\n\nimpl ColorComponentType for NumberOrPercentageComponent {\n fn from_value(value: f32) -> Self {\n Self::Number(value)\n }\n\n fn units() -> CalcUnits {\n CalcUnits::PERCENTAGE\n }\n\n fn try_from_token(token: &Token) -> Result {\n Ok(match *token {\n Token::Number { value, .. } => Self::Number(value),\n Token::Percentage { unit_value, .. } => Self::Percentage(unit_value),\n _ => {\n return Err(());\n },\n })\n }\n\n fn try_from_leaf(leaf: &Leaf) -> Result {\n Ok(match *leaf {\n Leaf::Percentage(unit_value) => Self::Percentage(unit_value),\n Leaf::Number(value) => Self::Number(value),\n _ => return Err(()),\n })\n }\n}\n\n/// Either an angle or a number.\n#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, ToAnimatedValue, ToShmem)]\n#[repr(u8)]\npub enum NumberOrAngleComponent {\n /// ``.\n Number(f32),\n /// ``\n /// The value as a number of degrees.\n Angle(f32),\n}\n\nimpl NumberOrAngleComponent {\n /// Return the angle in degrees. `NumberOrAngle::Number` is returned as\n /// degrees, because it is the canonical unit.\n pub fn degrees(&self) -> f32 {\n match *self {\n Self::Number(value) => value,\n Self::Angle(degrees) => degrees,\n }\n }\n}\n\nimpl ColorComponentType for NumberOrAngleComponent {\n fn from_value(value: f32) -> Self {\n Self::Number(value)\n }\n\n fn units() -> CalcUnits {\n CalcUnits::ANGLE\n }\n\n fn try_from_token(token: &Token) -> Result {\n Ok(match *token {\n Token::Number { value, .. } => Self::Number(value),\n Token::Dimension {\n value, ref unit, ..\n } => {\n let degrees =\n SpecifiedAngle::parse_dimension(value, unit, /* from_calc = */ false)\n .map(|angle| angle.degrees())?;\n\n NumberOrAngleComponent::Angle(degrees)\n },\n _ => {\n return Err(());\n },\n })\n }\n\n fn try_from_leaf(leaf: &Leaf) -> Result {\n Ok(match *leaf {\n Leaf::Angle(angle) => Self::Angle(angle.degrees()),\n Leaf::Number(value) => Self::Number(value),\n _ => return Err(()),\n })\n }\n}\n\n/// The raw f32 here is for .\nimpl ColorComponentType for f32 {\n fn from_value(value: f32) -> Self {\n value\n }\n\n fn units() -> CalcUnits {\n CalcUnits::empty()\n }\n\n fn try_from_token(token: &Token) -> Result {\n if let Token::Number { value, .. } = *token {\n Ok(value)\n } else {\n Err(())\n }\n }\n\n fn try_from_leaf(leaf: &Leaf) -> Result {\n if let Leaf::Number(value) = *leaf {\n Ok(value)\n } else {\n Err(())\n }\n }\n}\n\n/// Parse an `` or `` value.\nfn parse_number_or_angle<'i, 't>(\n context: &ParserContext,\n input: &mut Parser<'i, 't>,\n allow_none: bool,\n) -> Result, ParseError<'i>> {\n ColorComponent::parse(context, input, allow_none)\n}\n\n/// Parse a `` value.\nfn parse_percentage<'i, 't>(\n context: &ParserContext,\n input: &mut Parser<'i, 't>,\n allow_none: bool,\n) -> Result, ParseError<'i>> {\n let location = input.current_source_location();\n\n let value = ColorComponent::::parse(context, input, allow_none)?;\n if !value.could_be_percentage() {\n return Err(location.new_custom_error(StyleParseErrorKind::UnspecifiedError));\n }\n\n Ok(value)\n}\n\n/// Parse a `` value.\nfn parse_number<'i, 't>(\n context: &ParserContext,\n input: &mut Parser<'i, 't>,\n allow_none: bool,\n) -> Result, ParseError<'i>> {\n let location = input.current_source_location();\n\n let value = ColorComponent::::parse(context, input, allow_none)?;\n\n if !value.could_be_number() {\n return Err(location.new_custom_error(StyleParseErrorKind::UnspecifiedError));\n }\n\n Ok(value)\n}\n\n/// Parse a `` or `` value.\nfn parse_number_or_percentage<'i, 't>(\n context: &ParserContext,\n input: &mut Parser<'i, 't>,\n allow_none: bool,\n) -> Result, ParseError<'i>> {\n ColorComponent::parse(context, input, allow_none)\n}\n\nfn parse_legacy_alpha<'i, 't>(\n context: &ParserContext,\n arguments: &mut Parser<'i, 't>,\n) -> Result, ParseError<'i>> {\n if !arguments.is_exhausted() {\n arguments.expect_comma()?;\n parse_number_or_percentage(context, arguments, false)\n } else {\n Ok(ColorComponent::AlphaOmitted)\n }\n}\n\nfn parse_modern_alpha<'i, 't>(\n context: &ParserContext,\n arguments: &mut Parser<'i, 't>,\n) -> Result, ParseError<'i>> {\n if !arguments.is_exhausted() {\n arguments.expect_delim('/')?;\n parse_number_or_percentage(context, arguments, true)\n } else {\n Ok(ColorComponent::AlphaOmitted)\n }\n}\n\nimpl ColorComponent {\n /// Return true if the value contained inside is/can resolve to a number.\n /// Also returns false if the node is invalid somehow.\n fn could_be_number(&self) -> bool {\n match self {\n Self::None | Self::AlphaOmitted => true,\n Self::Value(value) => matches!(value, NumberOrPercentageComponent::Number { .. }),\n Self::ChannelKeyword(_) => {\n // Channel keywords always resolve to numbers.\n true\n },\n Self::Calc(node) => {\n if let Ok(unit) = node.unit() {\n unit.is_empty()\n } else {\n false\n }\n },\n }\n }\n\n /// Return true if the value contained inside is/can resolve to a percentage.\n /// Also returns false if the node is invalid somehow.\n fn could_be_percentage(&self) -> bool {\n match self {\n Self::None | Self::AlphaOmitted => true,\n Self::Value(value) => matches!(value, NumberOrPercentageComponent::Percentage { .. }),\n Self::ChannelKeyword(_) => {\n // Channel keywords always resolve to numbers.\n false\n },\n Self::Calc(node) => {\n if let Ok(unit) = node.unit() {\n unit == CalcUnits::PERCENTAGE\n } else {\n false\n }\n },\n }\n }\n}\n" }, { "path": "style/color/to_css.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! Write colors into CSS strings.\n\nuse super::{\n parsing::{NumberOrAngleComponent, NumberOrPercentageComponent},\n AbsoluteColor, ColorFlags, ColorSpace,\n};\nuse crate::values::normalize;\nuse cssparser::color::{clamp_unit_f32, serialize_color_alpha, OPAQUE};\nuse std::fmt::{self, Write};\nuse style_traits::{CssWriter, ToCss};\n\n/// A [`ModernComponent`] can serialize to `none`, `nan`, `infinity` and\n/// floating point values.\nstruct ModernComponent<'a>(&'a Option);\n\nimpl<'a> ToCss for ModernComponent<'a> {\n fn to_css(&self, dest: &mut CssWriter) -> fmt::Result\n where\n W: fmt::Write,\n {\n if let Some(value) = self.0 {\n if value.is_finite() {\n value.to_css(dest)\n } else if value.is_nan() {\n dest.write_str(\"calc(NaN)\")\n } else {\n debug_assert!(value.is_infinite());\n if value.is_sign_negative() {\n dest.write_str(\"calc(-infinity)\")\n } else {\n dest.write_str(\"calc(infinity)\")\n }\n }\n } else {\n dest.write_str(\"none\")\n }\n }\n}\n\nimpl ToCss for NumberOrPercentageComponent {\n fn to_css(&self, dest: &mut CssWriter) -> fmt::Result\n where\n W: Write,\n {\n use crate::values::computed::Percentage;\n\n match self {\n Self::Number(number) => number.to_css(dest)?,\n Self::Percentage(percentage) => Percentage(*percentage).to_css(dest)?,\n }\n Ok(())\n }\n}\n\nimpl ToCss for NumberOrAngleComponent {\n fn to_css(&self, dest: &mut CssWriter) -> fmt::Result\n where\n W: Write,\n {\n use crate::values::computed::Angle;\n\n match self {\n Self::Number(number) => number.to_css(dest)?,\n Self::Angle(degrees) => Angle::from_degrees(*degrees).to_css(dest)?,\n }\n Ok(())\n }\n}\n\nimpl ToCss for AbsoluteColor {\n fn to_css(&self, dest: &mut CssWriter) -> fmt::Result\n where\n W: Write,\n {\n match self.color_space {\n ColorSpace::Srgb if self.flags.contains(ColorFlags::IS_LEGACY_SRGB) => {\n // The \"none\" keyword is not supported in the rgb/rgba legacy syntax.\n let has_alpha = self.alpha != OPAQUE;\n\n dest.write_str(if has_alpha { \"rgba(\" } else { \"rgb(\" })?;\n clamp_unit_f32(self.components.0).to_css(dest)?;\n dest.write_str(\", \")?;\n clamp_unit_f32(self.components.1).to_css(dest)?;\n dest.write_str(\", \")?;\n clamp_unit_f32(self.components.2).to_css(dest)?;\n\n // Legacy syntax does not allow none components.\n serialize_color_alpha(dest, Some(self.alpha), true)?;\n\n dest.write_char(')')\n },\n ColorSpace::Hsl | ColorSpace::Hwb => {\n if self.flags.contains(ColorFlags::IS_LEGACY_SRGB) {\n self.into_srgb_legacy().to_css(dest)\n } else {\n self.to_color_space(ColorSpace::Srgb).to_css(dest)\n }\n },\n ColorSpace::Oklab | ColorSpace::Lab | ColorSpace::Oklch | ColorSpace::Lch => {\n if let ColorSpace::Oklab | ColorSpace::Oklch = self.color_space {\n dest.write_str(\"ok\")?;\n }\n if let ColorSpace::Oklab | ColorSpace::Lab = self.color_space {\n dest.write_str(\"lab(\")?;\n } else {\n dest.write_str(\"lch(\")?;\n }\n ModernComponent(&self.c0()).to_css(dest)?;\n dest.write_char(' ')?;\n ModernComponent(&self.c1()).to_css(dest)?;\n dest.write_char(' ')?;\n ModernComponent(&self.c2()).to_css(dest)?;\n serialize_color_alpha(dest, self.alpha(), false)?;\n dest.write_char(')')\n },\n _ => {\n #[cfg(debug_assertions)]\n match self.color_space {\n ColorSpace::Srgb => {\n debug_assert!(\n !self.flags.contains(ColorFlags::IS_LEGACY_SRGB),\n \"legacy srgb is not a color function\"\n );\n },\n ColorSpace::SrgbLinear\n | ColorSpace::DisplayP3\n | ColorSpace::DisplayP3Linear\n | ColorSpace::A98Rgb\n | ColorSpace::ProphotoRgb\n | ColorSpace::Rec2020\n | ColorSpace::XyzD50\n | ColorSpace::XyzD65 => {\n // These color spaces are allowed.\n },\n ColorSpace::Hsl\n | ColorSpace::Hwb\n | ColorSpace::Lab\n | ColorSpace::Oklab\n | ColorSpace::Lch\n | ColorSpace::Oklch => {\n unreachable!(\"other color spaces do not support color() syntax\")\n },\n };\n\n dest.write_str(\"color(\")?;\n self.color_space.to_css(dest)?;\n dest.write_char(' ')?;\n ModernComponent(&self.c0()).to_css(dest)?;\n dest.write_char(' ')?;\n ModernComponent(&self.c1()).to_css(dest)?;\n dest.write_char(' ')?;\n ModernComponent(&self.c2()).to_css(dest)?;\n\n serialize_color_alpha(dest, self.alpha(), false)?;\n\n dest.write_char(')')\n },\n }\n }\n}\n\nimpl AbsoluteColor {\n /// Write a string to `dest` that represents a color as an author would\n /// enter it.\n /// NOTE: The format of the output is NOT according to any specification,\n /// but makes assumptions about the best ways that authors would want to\n /// enter color values in style sheets, devtools, etc.\n pub fn write_author_preferred_value(&self, dest: &mut CssWriter) -> fmt::Result\n where\n W: Write,\n {\n macro_rules! precision {\n ($v:expr) => {{\n ($v * 100.0).round() / 100.0\n }};\n }\n macro_rules! number {\n ($c:expr) => {{\n if let Some(v) = $c.map(normalize) {\n precision!(v).to_css(dest)?;\n } else {\n write!(dest, \"none\")?;\n }\n }};\n }\n macro_rules! percentage {\n ($c:expr) => {{\n if let Some(v) = $c.map(normalize) {\n precision!(v).to_css(dest)?;\n dest.write_char('%')?;\n } else {\n write!(dest, \"none\")?;\n }\n }};\n }\n macro_rules! unit_percentage {\n ($c:expr) => {{\n if let Some(v) = $c.map(normalize) {\n precision!(v * 100.0).to_css(dest)?;\n dest.write_char('%')?;\n } else {\n write!(dest, \"none\")?;\n }\n }};\n }\n macro_rules! angle {\n ($c:expr) => {{\n if let Some(v) = $c.map(normalize) {\n precision!(v).to_css(dest)?;\n dest.write_str(\"deg\")?;\n } else {\n write!(dest, \"none\")?;\n }\n }};\n }\n\n match self.color_space {\n ColorSpace::Srgb => {\n write!(dest, \"rgb(\")?;\n unit_percentage!(self.c0());\n dest.write_char(' ')?;\n unit_percentage!(self.c1());\n dest.write_char(' ')?;\n unit_percentage!(self.c2());\n serialize_color_alpha(dest, self.alpha(), false)?;\n dest.write_char(')')\n },\n ColorSpace::Hsl | ColorSpace::Hwb => {\n dest.write_str(if self.color_space == ColorSpace::Hsl {\n \"hsl(\"\n } else {\n \"hwb(\"\n })?;\n angle!(self.c0());\n dest.write_char(' ')?;\n percentage!(self.c1());\n dest.write_char(' ')?;\n percentage!(self.c2());\n serialize_color_alpha(dest, self.alpha(), false)?;\n dest.write_char(')')\n },\n ColorSpace::Lab | ColorSpace::Oklab => {\n if self.color_space == ColorSpace::Oklab {\n dest.write_str(\"ok\")?;\n }\n dest.write_str(\"lab(\")?;\n if self.color_space == ColorSpace::Lab {\n percentage!(self.c0())\n } else {\n unit_percentage!(self.c0())\n }\n dest.write_char(' ')?;\n number!(self.c1());\n dest.write_char(' ')?;\n number!(self.c2());\n serialize_color_alpha(dest, self.alpha(), false)?;\n dest.write_char(')')\n },\n ColorSpace::Lch | ColorSpace::Oklch => {\n if self.color_space == ColorSpace::Oklch {\n dest.write_str(\"ok\")?;\n }\n dest.write_str(\"lch(\")?;\n number!(self.c0());\n dest.write_char(' ')?;\n number!(self.c1());\n dest.write_char(' ')?;\n angle!(self.c2());\n serialize_color_alpha(dest, self.alpha(), false)?;\n dest.write_char(')')\n },\n ColorSpace::SrgbLinear\n | ColorSpace::DisplayP3\n | ColorSpace::DisplayP3Linear\n | ColorSpace::A98Rgb\n | ColorSpace::ProphotoRgb\n | ColorSpace::Rec2020\n | ColorSpace::XyzD50\n | ColorSpace::XyzD65 => {\n dest.write_str(\"color(\")?;\n self.color_space.to_css(dest)?;\n dest.write_char(' ')?;\n number!(self.c0());\n dest.write_char(' ')?;\n number!(self.c1());\n dest.write_char(' ')?;\n number!(self.c2());\n serialize_color_alpha(dest, self.alpha(), false)?;\n dest.write_char(')')\n },\n }\n }\n}\n" }, { "path": "style/context.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! The context within which style is calculated.\n\n#[cfg(feature = \"servo\")]\nuse crate::animation::DocumentAnimationSet;\nuse crate::bloom::StyleBloom;\nuse crate::computed_value_flags::ComputedValueFlags;\nuse crate::data::{EagerPseudoStyles, ElementData};\nuse crate::derives::*;\nuse crate::dom::{SendElement, TElement};\n#[cfg(feature = \"gecko\")]\nuse crate::gecko_bindings::structs;\nuse crate::parallel::{STACK_SAFETY_MARGIN_KB, STYLE_THREAD_STACK_SIZE_KB};\nuse crate::properties::ComputedValues;\n#[cfg(feature = \"servo\")]\nuse crate::properties::PropertyId;\nuse crate::rule_cache::RuleCache;\nuse crate::rule_tree::{RuleCascadeFlags, StrongRuleNode};\nuse crate::selector_parser::{SnapshotMap, EAGER_PSEUDO_COUNT};\nuse crate::shared_lock::StylesheetGuards;\nuse crate::sharing::StyleSharingCache;\nuse crate::stylist::Stylist;\nuse crate::thread_state::{self, ThreadState};\nuse crate::traversal::DomTraversal;\nuse crate::traversal_flags::TraversalFlags;\nuse app_units::Au;\nuse euclid::default::Size2D;\nuse euclid::Scale;\n#[cfg(feature = \"servo\")]\nuse rustc_hash::FxHashMap;\nuse selectors::context::SelectorCaches;\n#[cfg(feature = \"gecko\")]\nuse servo_arc::Arc;\nuse std::fmt;\nuse std::ops;\nuse std::time::{Duration, Instant};\nuse style_traits::CSSPixel;\nuse style_traits::DevicePixel;\n#[cfg(feature = \"servo\")]\nuse style_traits::SpeculativePainter;\n#[cfg(feature = \"servo\")]\nuse stylo_atoms::Atom;\n\npub use selectors::matching::QuirksMode;\n\n/// A global options structure for the style system. We use this instead of\n/// opts to abstract across Gecko and Servo.\n#[derive(Clone)]\npub struct StyleSystemOptions {\n /// Whether the style sharing cache is disabled.\n pub disable_style_sharing_cache: bool,\n /// Whether we should dump statistics about the style system.\n pub dump_style_statistics: bool,\n /// The minimum number of elements that must be traversed to trigger a dump\n /// of style statistics.\n pub style_statistics_threshold: usize,\n}\n\n#[cfg(feature = \"gecko\")]\nfn get_env_bool(name: &str) -> bool {\n use std::env;\n match env::var(name) {\n Ok(s) => !s.is_empty(),\n Err(_) => false,\n }\n}\n\nconst DEFAULT_STATISTICS_THRESHOLD: usize = 50;\n\n#[cfg(feature = \"gecko\")]\nfn get_env_usize(name: &str) -> Option {\n use std::env;\n env::var(name).ok().map(|s| {\n s.parse::()\n .expect(\"Couldn't parse environmental variable as usize\")\n })\n}\n\n/// A global variable holding the state of\n/// `StyleSystemOptions::default().disable_style_sharing_cache`.\n/// See [#22854](https://github.com/servo/servo/issues/22854).\n#[cfg(feature = \"servo\")]\npub static DEFAULT_DISABLE_STYLE_SHARING_CACHE: std::sync::atomic::AtomicBool =\n std::sync::atomic::AtomicBool::new(false);\n\n/// A global variable holding the state of\n/// `StyleSystemOptions::default().dump_style_statistics`.\n/// See [#22854](https://github.com/servo/servo/issues/22854).\n#[cfg(feature = \"servo\")]\npub static DEFAULT_DUMP_STYLE_STATISTICS: std::sync::atomic::AtomicBool =\n std::sync::atomic::AtomicBool::new(false);\n\nimpl Default for StyleSystemOptions {\n #[cfg(feature = \"servo\")]\n fn default() -> Self {\n use std::sync::atomic::Ordering;\n\n StyleSystemOptions {\n disable_style_sharing_cache: DEFAULT_DISABLE_STYLE_SHARING_CACHE\n .load(Ordering::Relaxed),\n dump_style_statistics: DEFAULT_DUMP_STYLE_STATISTICS.load(Ordering::Relaxed),\n style_statistics_threshold: DEFAULT_STATISTICS_THRESHOLD,\n }\n }\n\n #[cfg(feature = \"gecko\")]\n fn default() -> Self {\n StyleSystemOptions {\n disable_style_sharing_cache: get_env_bool(\"DISABLE_STYLE_SHARING_CACHE\"),\n dump_style_statistics: get_env_bool(\"DUMP_STYLE_STATISTICS\"),\n style_statistics_threshold: get_env_usize(\"STYLE_STATISTICS_THRESHOLD\")\n .unwrap_or(DEFAULT_STATISTICS_THRESHOLD),\n }\n }\n}\n\n/// A shared style context.\n///\n/// There's exactly one of these during a given restyle traversal, and it's\n/// shared among the worker threads.\npub struct SharedStyleContext<'a> {\n /// The CSS selector stylist.\n pub stylist: &'a Stylist,\n\n /// Whether visited styles are enabled.\n ///\n /// They may be disabled when Gecko's pref layout.css.visited_links_enabled\n /// is false, or when in private browsing mode.\n pub visited_styles_enabled: bool,\n\n /// Configuration options.\n pub options: StyleSystemOptions,\n\n /// Guards for pre-acquired locks\n pub guards: StylesheetGuards<'a>,\n\n /// The current time for transitions and animations. This is needed to ensure\n /// a consistent sampling time and also to adjust the time for testing.\n pub current_time_for_animations: f64,\n\n /// Flags controlling how we traverse the tree.\n pub traversal_flags: TraversalFlags,\n\n /// A map with our snapshots in order to handle restyle hints.\n pub snapshot_map: &'a SnapshotMap,\n\n /// The state of all animations for our styled elements.\n #[cfg(feature = \"servo\")]\n pub animations: DocumentAnimationSet,\n\n /// Paint worklets\n #[cfg(feature = \"servo\")]\n pub registered_speculative_painters: &'a dyn RegisteredSpeculativePainters,\n}\n\nimpl<'a> SharedStyleContext<'a> {\n /// Return a suitable viewport size in order to be used for viewport units.\n pub fn viewport_size(&self) -> Size2D {\n self.stylist.device().au_viewport_size()\n }\n\n /// The device pixel ratio\n pub fn device_pixel_ratio(&self) -> Scale {\n self.stylist.device().device_pixel_ratio()\n }\n\n /// The quirks mode of the document.\n pub fn quirks_mode(&self) -> QuirksMode {\n self.stylist.quirks_mode()\n }\n}\n\n/// The structure holds various intermediate inputs that are eventually used by\n/// by the cascade.\n///\n/// The matching and cascading process stores them in this format temporarily\n/// within the `CurrentElementInfo`. At the end of the cascade, they are folded\n/// down into the main `ComputedValues` to reduce memory usage per element while\n/// still remaining accessible.\n#[derive(Clone, Debug, Default)]\npub struct CascadeInputs {\n /// The rule node representing the ordered list of rules matched for this\n /// node.\n pub rules: Option,\n\n /// The rule node representing the ordered list of rules matched for this\n /// node if visited, only computed if there's a relevant link for this\n /// element. A element's \"relevant link\" is the element being matched if it\n /// is a link or the nearest ancestor link.\n pub visited_rules: Option,\n\n /// The set of flags from container queries that we need for invalidation.\n pub flags: ComputedValueFlags,\n\n /// The set of RuleCascadeFlags to include in the cascade.\n pub included_cascade_flags: RuleCascadeFlags,\n}\n\nimpl CascadeInputs {\n /// Construct inputs from previous cascade results, if any.\n pub fn new_from_style(style: &ComputedValues) -> Self {\n Self {\n rules: style.rules.clone(),\n visited_rules: style.visited_style().and_then(|v| v.rules.clone()),\n flags: style.flags.for_cascade_inputs(),\n included_cascade_flags: RuleCascadeFlags::empty(),\n }\n }\n}\n\n/// A list of cascade inputs for eagerly-cascaded pseudo-elements.\n/// The list is stored inline.\n#[derive(Debug)]\npub struct EagerPseudoCascadeInputs(Option<[Option; EAGER_PSEUDO_COUNT]>);\n\n// Manually implement `Clone` here because the derived impl of `Clone` for\n// array types assumes the value inside is `Copy`.\nimpl Clone for EagerPseudoCascadeInputs {\n fn clone(&self) -> Self {\n if self.0.is_none() {\n return EagerPseudoCascadeInputs(None);\n }\n let self_inputs = self.0.as_ref().unwrap();\n let mut inputs: [Option; EAGER_PSEUDO_COUNT] = Default::default();\n for i in 0..EAGER_PSEUDO_COUNT {\n inputs[i] = self_inputs[i].clone();\n }\n EagerPseudoCascadeInputs(Some(inputs))\n }\n}\n\nimpl EagerPseudoCascadeInputs {\n /// Construct inputs from previous cascade results, if any.\n fn new_from_style(styles: &EagerPseudoStyles) -> Self {\n EagerPseudoCascadeInputs(styles.as_optional_array().map(|styles| {\n let mut inputs: [Option; EAGER_PSEUDO_COUNT] = Default::default();\n for i in 0..EAGER_PSEUDO_COUNT {\n inputs[i] = styles[i].as_ref().map(|s| CascadeInputs::new_from_style(s));\n }\n inputs\n }))\n }\n\n /// Returns the list of rules, if they exist.\n pub fn into_array(self) -> Option<[Option; EAGER_PSEUDO_COUNT]> {\n self.0\n }\n}\n\n/// The cascade inputs associated with a node, including those for any\n/// pseudo-elements.\n///\n/// The matching and cascading process stores them in this format temporarily\n/// within the `CurrentElementInfo`. At the end of the cascade, they are folded\n/// down into the main `ComputedValues` to reduce memory usage per element while\n/// still remaining accessible.\n#[derive(Clone, Debug)]\npub struct ElementCascadeInputs {\n /// The element's cascade inputs.\n pub primary: CascadeInputs,\n /// A list of the inputs for the element's eagerly-cascaded pseudo-elements.\n pub pseudos: EagerPseudoCascadeInputs,\n}\n\nimpl ElementCascadeInputs {\n /// Construct inputs from previous cascade results, if any.\n #[inline]\n pub fn new_from_element_data(data: &ElementData) -> Self {\n debug_assert!(data.has_styles());\n ElementCascadeInputs {\n primary: CascadeInputs::new_from_style(data.styles.primary()),\n pseudos: EagerPseudoCascadeInputs::new_from_style(&data.styles.pseudos),\n }\n }\n}\n\n/// Statistics gathered during the traversal. We gather statistics on each\n/// thread and then combine them after the threads join via the Add\n/// implementation below.\n#[derive(AddAssign, Clone, Default)]\npub struct PerThreadTraversalStatistics {\n /// The total number of elements traversed.\n pub elements_traversed: u32,\n /// The number of elements where has_styles() went from false to true.\n pub elements_styled: u32,\n /// The number of elements for which we performed selector matching.\n pub elements_matched: u32,\n /// The number of cache hits from the StyleSharingCache.\n pub styles_shared: u32,\n /// The number of styles reused via rule node comparison from the\n /// StyleSharingCache.\n pub styles_reused: u32,\n}\n\n/// Statistics gathered during the traversal plus some information from\n/// other sources including stylist.\n#[derive(Default)]\npub struct TraversalStatistics {\n /// Aggregated statistics gathered during the traversal.\n pub aggregated: PerThreadTraversalStatistics,\n /// The number of selectors in the stylist.\n pub selectors: u32,\n /// The number of revalidation selectors.\n pub revalidation_selectors: u32,\n /// The number of state/attr dependencies in the dependency set.\n pub dependency_selectors: u32,\n /// The number of declarations in the stylist.\n pub declarations: u32,\n /// The number of times the stylist was rebuilt.\n pub stylist_rebuilds: u32,\n /// Time spent in the traversal, in milliseconds.\n pub traversal_time: Duration,\n /// Whether this was a parallel traversal.\n pub is_parallel: bool,\n /// Whether this is a \"large\" traversal.\n pub is_large: bool,\n}\n\n/// Format the statistics in a way that the performance test harness understands.\n/// See https://bugzilla.mozilla.org/show_bug.cgi?id=1331856#c2\nimpl fmt::Display for TraversalStatistics {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n writeln!(f, \"[PERF] perf block start\")?;\n writeln!(\n f,\n \"[PERF],traversal,{}\",\n if self.is_parallel {\n \"parallel\"\n } else {\n \"sequential\"\n }\n )?;\n writeln!(\n f,\n \"[PERF],elements_traversed,{}\",\n self.aggregated.elements_traversed\n )?;\n writeln!(\n f,\n \"[PERF],elements_styled,{}\",\n self.aggregated.elements_styled\n )?;\n writeln!(\n f,\n \"[PERF],elements_matched,{}\",\n self.aggregated.elements_matched\n )?;\n writeln!(f, \"[PERF],styles_shared,{}\", self.aggregated.styles_shared)?;\n writeln!(f, \"[PERF],styles_reused,{}\", self.aggregated.styles_reused)?;\n writeln!(f, \"[PERF],selectors,{}\", self.selectors)?;\n writeln!(\n f,\n \"[PERF],revalidation_selectors,{}\",\n self.revalidation_selectors\n )?;\n writeln!(\n f,\n \"[PERF],dependency_selectors,{}\",\n self.dependency_selectors\n )?;\n writeln!(f, \"[PERF],declarations,{}\", self.declarations)?;\n writeln!(f, \"[PERF],stylist_rebuilds,{}\", self.stylist_rebuilds)?;\n writeln!(\n f,\n \"[PERF],traversal_time_ms,{}\",\n self.traversal_time.as_secs_f64() * 1000.\n )?;\n writeln!(f, \"[PERF] perf block end\")\n }\n}\n\nimpl TraversalStatistics {\n /// Generate complete traversal statistics.\n ///\n /// The traversal time is computed given the start time in seconds.\n pub fn new(\n aggregated: PerThreadTraversalStatistics,\n traversal: &D,\n parallel: bool,\n start: Instant,\n ) -> TraversalStatistics\n where\n E: TElement,\n D: DomTraversal,\n {\n let threshold = traversal\n .shared_context()\n .options\n .style_statistics_threshold;\n let stylist = traversal.shared_context().stylist;\n let is_large = aggregated.elements_traversed as usize >= threshold;\n TraversalStatistics {\n aggregated,\n selectors: stylist.num_selectors() as u32,\n revalidation_selectors: stylist.num_revalidation_selectors() as u32,\n dependency_selectors: stylist.num_invalidations() as u32,\n declarations: stylist.num_declarations() as u32,\n stylist_rebuilds: stylist.num_rebuilds() as u32,\n traversal_time: Instant::now() - start,\n is_parallel: parallel,\n is_large,\n }\n }\n}\n\n#[cfg(feature = \"gecko\")]\nbitflags! {\n /// Represents which tasks are performed in a SequentialTask of\n /// UpdateAnimations which is a result of normal restyle.\n pub struct UpdateAnimationsTasks: u8 {\n /// Update CSS Animations.\n const CSS_ANIMATIONS = structs::UpdateAnimationsTasks_CSSAnimations;\n /// Update CSS Transitions.\n const CSS_TRANSITIONS = structs::UpdateAnimationsTasks_CSSTransitions;\n /// Update effect properties.\n const EFFECT_PROPERTIES = structs::UpdateAnimationsTasks_EffectProperties;\n /// Update animation cacade results for animations running on the compositor.\n const CASCADE_RESULTS = structs::UpdateAnimationsTasks_CascadeResults;\n /// Display property was changed from none.\n /// Script animations keep alive on display:none elements, so we need to trigger\n /// the second animation restyles for the script animations in the case where\n /// the display property was changed from 'none' to others.\n const DISPLAY_CHANGED_FROM_NONE = structs::UpdateAnimationsTasks_DisplayChangedFromNone;\n /// Update CSS named scroll progress timelines.\n const SCROLL_TIMELINES = structs::UpdateAnimationsTasks_ScrollTimelines;\n /// Update CSS named view progress timelines.\n const VIEW_TIMELINES = structs::UpdateAnimationsTasks_ViewTimelines;\n /// Update CSS timeline scopes, which affect visibility of both scroll and view timelines.\n const TIMELINE_SCOPES = structs::UpdateAnimationsTasks_TimelineScopes;\n }\n}\n\n/// A task to be run in sequential mode on the parent (non-worker) thread. This\n/// is used by the style system to queue up work which is not safe to do during\n/// the parallel traversal.\npub enum SequentialTask {\n /// Entry to avoid an unused type parameter error on servo.\n Unused(SendElement),\n\n /// Performs one of a number of possible tasks related to updating\n /// animations based on the |tasks| field. These include updating CSS\n /// animations/transitions that changed as part of the non-animation style\n /// traversal, and updating the computed effect properties.\n #[cfg(feature = \"gecko\")]\n UpdateAnimations {\n /// The target element or pseudo-element.\n el: SendElement,\n /// The before-change style for transitions. We use before-change style\n /// as the initial value of its Keyframe. Required if |tasks| includes\n /// CSSTransitions.\n before_change_style: Option>,\n /// The tasks which are performed in this SequentialTask.\n tasks: UpdateAnimationsTasks,\n },\n}\n\nimpl SequentialTask {\n /// Executes this task.\n pub fn execute(self) {\n use self::SequentialTask::*;\n debug_assert!(thread_state::get().contains(ThreadState::LAYOUT));\n match self {\n Unused(_) => unreachable!(),\n #[cfg(feature = \"gecko\")]\n UpdateAnimations {\n el,\n before_change_style,\n tasks,\n } => {\n el.update_animations(before_change_style, tasks);\n },\n }\n }\n\n /// Creates a task to update various animation-related state on a given\n /// (pseudo-)element.\n #[cfg(feature = \"gecko\")]\n pub fn update_animations(\n el: E,\n before_change_style: Option>,\n tasks: UpdateAnimationsTasks,\n ) -> Self {\n use self::SequentialTask::*;\n UpdateAnimations {\n el: unsafe { SendElement::new(el) },\n before_change_style,\n tasks,\n }\n }\n}\n\n/// A list of SequentialTasks that get executed on Drop.\npub struct SequentialTaskList(Vec>)\nwhere\n E: TElement;\n\nimpl ops::Deref for SequentialTaskList\nwhere\n E: TElement,\n{\n type Target = Vec>;\n\n fn deref(&self) -> &Self::Target {\n &self.0\n }\n}\n\nimpl ops::DerefMut for SequentialTaskList\nwhere\n E: TElement,\n{\n fn deref_mut(&mut self) -> &mut Self::Target {\n &mut self.0\n }\n}\n\nimpl Drop for SequentialTaskList\nwhere\n E: TElement,\n{\n fn drop(&mut self) {\n debug_assert!(thread_state::get().contains(ThreadState::LAYOUT));\n for task in self.0.drain(..) {\n task.execute()\n }\n }\n}\n\n/// A helper type for stack limit checking. This assumes that stacks grow\n/// down, which is true for all non-ancient CPU architectures.\npub struct StackLimitChecker {\n lower_limit: usize,\n}\n\nimpl StackLimitChecker {\n /// Create a new limit checker, for this thread, allowing further use\n /// of up to |stack_size| bytes beyond (below) the current stack pointer.\n #[inline(never)]\n pub fn new(stack_size_limit: usize) -> Self {\n StackLimitChecker {\n lower_limit: StackLimitChecker::get_sp() - stack_size_limit,\n }\n }\n\n /// Checks whether the previously stored stack limit has now been exceeded.\n #[inline(never)]\n pub fn limit_exceeded(&self) -> bool {\n let curr_sp = StackLimitChecker::get_sp();\n\n // Do some sanity-checking to ensure that our invariants hold, even in\n // the case where we've exceeded the soft limit.\n //\n // The correctness of depends on the assumption that no stack wraps\n // around the end of the address space.\n if cfg!(debug_assertions) {\n // Compute the actual bottom of the stack by subtracting our safety\n // margin from our soft limit. Note that this will be slightly below\n // the actual bottom of the stack, because there are a few initial\n // frames on the stack before we do the measurement that computes\n // the limit.\n let stack_bottom = self.lower_limit - STACK_SAFETY_MARGIN_KB * 1024;\n\n // The bottom of the stack should be below the current sp. If it\n // isn't, that means we've either waited too long to check the limit\n // and burned through our safety margin (in which case we probably\n // would have segfaulted by now), or we're using a limit computed for\n // a different thread.\n debug_assert!(stack_bottom < curr_sp);\n\n // Compute the distance between the current sp and the bottom of\n // the stack, and compare it against the current stack. It should be\n // no further from us than the total stack size. We allow some slop\n // to handle the fact that stack_bottom is a bit further than the\n // bottom of the stack, as discussed above.\n let distance_to_stack_bottom = curr_sp - stack_bottom;\n let max_allowable_distance = (STYLE_THREAD_STACK_SIZE_KB + 10) * 1024;\n debug_assert!(distance_to_stack_bottom <= max_allowable_distance);\n }\n\n // The actual bounds check.\n curr_sp <= self.lower_limit\n }\n\n // Technically, rustc can optimize this away, but shouldn't for now.\n // We should fix this once black_box is stable.\n #[inline(always)]\n fn get_sp() -> usize {\n let mut foo: usize = 42;\n (&mut foo as *mut usize) as usize\n }\n}\n\n/// A thread-local style context.\n///\n/// This context contains data that needs to be used during restyling, but is\n/// not required to be unique among worker threads, so we create one per worker\n/// thread in order to be able to mutate it without locking.\npub struct ThreadLocalStyleContext {\n /// A cache to share style among siblings.\n pub sharing_cache: StyleSharingCache,\n /// A cache from matched properties to elements that match those.\n pub rule_cache: RuleCache,\n /// The bloom filter used to fast-reject selector-matching.\n pub bloom_filter: StyleBloom,\n /// A set of tasks to be run (on the parent thread) in sequential mode after\n /// the rest of the styling is complete. This is useful for\n /// infrequently-needed non-threadsafe operations.\n ///\n /// It's important that goes after the style sharing cache and the bloom\n /// filter, to ensure they're dropped before we execute the tasks, which\n /// could create another ThreadLocalStyleContext for style computation.\n pub tasks: SequentialTaskList,\n /// Statistics about the traversal.\n pub statistics: PerThreadTraversalStatistics,\n /// A checker used to ensure that parallel.rs does not recurse indefinitely\n /// even on arbitrarily deep trees. See Gecko bug 1376883.\n pub stack_limit_checker: StackLimitChecker,\n /// Collection of caches (And cache-likes) for speeding up expensive selector matches.\n pub selector_caches: SelectorCaches,\n}\n\nimpl ThreadLocalStyleContext {\n /// Creates a new `ThreadLocalStyleContext`\n pub fn new() -> Self {\n ThreadLocalStyleContext {\n sharing_cache: StyleSharingCache::new(),\n rule_cache: RuleCache::new(),\n bloom_filter: StyleBloom::new(),\n tasks: SequentialTaskList(Vec::new()),\n statistics: PerThreadTraversalStatistics::default(),\n stack_limit_checker: StackLimitChecker::new(\n (STYLE_THREAD_STACK_SIZE_KB - STACK_SAFETY_MARGIN_KB) * 1024,\n ),\n selector_caches: SelectorCaches::default(),\n }\n }\n}\n\n/// A `StyleContext` is just a simple container for a immutable reference to a\n/// shared style context, and a mutable reference to a local one.\npub struct StyleContext<'a, E: TElement + 'a> {\n /// The shared style context reference.\n pub shared: &'a SharedStyleContext<'a>,\n /// The thread-local style context (mutable) reference.\n pub thread_local: &'a mut ThreadLocalStyleContext,\n}\n\n/// A registered painter\n#[cfg(feature = \"servo\")]\npub trait RegisteredSpeculativePainter: SpeculativePainter {\n /// The name it was registered with\n fn name(&self) -> Atom;\n /// The properties it was registered with\n fn properties(&self) -> &FxHashMap;\n}\n\n/// A set of registered painters\n#[cfg(feature = \"servo\")]\npub trait RegisteredSpeculativePainters: Sync {\n /// Look up a speculative painter\n fn get(&self, name: &Atom) -> Option<&dyn RegisteredSpeculativePainter>;\n}\n" }, { "path": "style/counter_style/mod.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! The [`@counter-style`][counter-style] at-rule.\n//!\n//! [counter-style]: https://drafts.csswg.org/css-counter-styles/\n\nuse crate::derives::*;\nuse crate::error_reporting::ContextualParseError;\nuse crate::parser::{Parse, ParserContext};\nuse crate::shared_lock::{SharedRwLockReadGuard, ToCssWithGuard};\nuse crate::values::specified::Integer;\nuse crate::values::{AtomString, CustomIdent};\nuse crate::Atom;\nuse cssparser::{\n ascii_case_insensitive_phf_map, match_ignore_ascii_case, CowRcStr, Parser, RuleBodyParser,\n SourceLocation, Token,\n};\nuse std::fmt::{self, Write};\nuse std::mem;\nuse std::num::Wrapping;\nuse style_traits::{\n Comma, CssStringWriter, CssWriter, KeywordsCollectFn, OneOrMoreSeparated, ParseError,\n SpecifiedValueInfo, StyleParseErrorKind, ToCss,\n};\n\npub use crate::properties::counter_style::{DescriptorId, DescriptorParser, Descriptors};\n\n/// https://drafts.csswg.org/css-counter-styles/#typedef-symbols-type\n#[allow(missing_docs)]\n#[cfg_attr(feature = \"servo\", derive(Deserialize, Serialize))]\n#[derive(\n Clone,\n Copy,\n Debug,\n Eq,\n MallocSizeOf,\n Parse,\n PartialEq,\n ToComputedValue,\n ToCss,\n ToResolvedValue,\n ToShmem,\n)]\n#[repr(u8)]\npub enum SymbolsType {\n Cyclic,\n Numeric,\n Alphabetic,\n Symbolic,\n Fixed,\n}\n\n/// \n///\n/// Note that 'none' is not a valid name, but we include this (along with String) for space\n/// efficiency when storing list-style-type.\n#[derive(\n Clone, Debug, Eq, MallocSizeOf, PartialEq, ToComputedValue, ToCss, ToResolvedValue, ToShmem,\n)]\n#[repr(u8)]\npub enum CounterStyle {\n /// The 'none' value.\n None,\n /// ``\n Name(CustomIdent),\n /// `symbols()`\n #[css(function)]\n Symbols {\n /// The , or symbolic if not specified.\n #[css(skip_if = \"is_symbolic\")]\n ty: SymbolsType,\n /// The actual symbols.\n symbols: Symbols,\n },\n /// A single string value, useful for ``.\n String(AtomString),\n}\n\n#[inline]\nfn is_symbolic(symbols_type: &SymbolsType) -> bool {\n *symbols_type == SymbolsType::Symbolic\n}\n\nimpl CounterStyle {\n /// disc value\n pub fn disc() -> Self {\n CounterStyle::Name(CustomIdent(atom!(\"disc\")))\n }\n\n /// decimal value\n pub fn decimal() -> Self {\n CounterStyle::Name(CustomIdent(atom!(\"decimal\")))\n }\n\n /// Is this a bullet? (i.e. `list-style-type: disc|circle|square|disclosure-closed|disclosure-open`)\n #[inline]\n pub fn is_bullet(&self) -> bool {\n match self {\n CounterStyle::Name(CustomIdent(ref name)) => {\n name == &atom!(\"disc\")\n || name == &atom!(\"circle\")\n || name == &atom!(\"square\")\n || name == &atom!(\"disclosure-closed\")\n || name == &atom!(\"disclosure-open\")\n },\n _ => false,\n }\n }\n}\n\nbitflags! {\n #[derive(Clone, Copy)]\n /// Flags to control parsing of counter styles.\n pub struct CounterStyleParsingFlags: u8 {\n /// Whether `none` is allowed.\n const ALLOW_NONE = 1 << 0;\n /// Whether a bare string is allowed.\n const ALLOW_STRING = 1 << 1;\n }\n}\n\nimpl CounterStyle {\n /// Parse a counter style, and optionally none|string (for list-style-type).\n pub fn parse<'i, 't>(\n context: &ParserContext,\n input: &mut Parser<'i, 't>,\n flags: CounterStyleParsingFlags,\n ) -> Result> {\n use self::CounterStyleParsingFlags as Flags;\n let location = input.current_source_location();\n match input.next()? {\n Token::QuotedString(ref string) if flags.intersects(Flags::ALLOW_STRING) => {\n Ok(Self::String(AtomString::from(string.as_ref())))\n },\n Token::Ident(ref ident) => {\n if flags.intersects(Flags::ALLOW_NONE) && ident.eq_ignore_ascii_case(\"none\") {\n return Ok(Self::None);\n }\n Ok(Self::Name(counter_style_name_from_ident(ident, location)?))\n },\n Token::Function(ref name) if name.eq_ignore_ascii_case(\"symbols\") => {\n input.parse_nested_block(|input| {\n let symbols_type = input\n .try_parse(SymbolsType::parse)\n .unwrap_or(SymbolsType::Symbolic);\n let symbols = Symbols::parse(context, input)?;\n // There must be at least two symbols for alphabetic or\n // numeric system.\n if (symbols_type == SymbolsType::Alphabetic\n || symbols_type == SymbolsType::Numeric)\n && symbols.0.len() < 2\n {\n return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError));\n }\n // Identifier is not allowed in symbols() function.\n if symbols.0.iter().any(|sym| !sym.is_allowed_in_symbols()) {\n return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError));\n }\n Ok(Self::Symbols {\n ty: symbols_type,\n symbols,\n })\n })\n },\n t => Err(location.new_unexpected_token_error(t.clone())),\n }\n }\n}\n\nimpl SpecifiedValueInfo for CounterStyle {\n fn collect_completion_keywords(f: KeywordsCollectFn) {\n // XXX The best approach for implementing this is probably\n // having a CounterStyleName type wrapping CustomIdent, and\n // put the predefined list for that type in counter_style mod.\n // But that's a non-trivial change itself, so we use a simpler\n // approach here.\n macro_rules! predefined {\n ($($name:expr,)+) => {\n f(&[\"symbols\", \"none\", $($name,)+])\n }\n }\n include!(\"predefined.rs\");\n }\n}\n\nfn parse_counter_style_name<'i>(input: &mut Parser<'i, '_>) -> Result> {\n let location = input.current_source_location();\n let ident = input.expect_ident()?;\n counter_style_name_from_ident(ident, location)\n}\n\n/// This allows the reserved counter style names \"decimal\" and \"disc\".\nfn counter_style_name_from_ident<'i>(\n ident: &CowRcStr<'i>,\n location: SourceLocation,\n) -> Result> {\n macro_rules! predefined {\n ($($name: tt,)+) => {{\n ascii_case_insensitive_phf_map! {\n predefined -> Atom = {\n $(\n $name => atom!($name),\n )+\n }\n }\n\n // This effectively performs case normalization only on predefined names.\n if let Some(lower_case) = predefined::get(&ident) {\n Ok(CustomIdent(lower_case.clone()))\n } else {\n // none is always an invalid value.\n CustomIdent::from_ident(location, ident, &[\"none\"])\n }\n }}\n }\n include!(\"predefined.rs\")\n}\n\nfn is_valid_name_definition(ident: &CustomIdent) -> bool {\n ident.0 != atom!(\"decimal\")\n && ident.0 != atom!(\"disc\")\n && ident.0 != atom!(\"circle\")\n && ident.0 != atom!(\"square\")\n && ident.0 != atom!(\"disclosure-closed\")\n && ident.0 != atom!(\"disclosure-open\")\n}\n\n/// Parse the prelude of an @counter-style rule\npub fn parse_counter_style_name_definition<'i, 't>(\n input: &mut Parser<'i, 't>,\n) -> Result> {\n parse_counter_style_name(input).and_then(|ident| {\n if !is_valid_name_definition(&ident) {\n Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError))\n } else {\n Ok(ident)\n }\n })\n}\n\n/// A @counter-style rule\n#[derive(Clone, Debug, ToShmem)]\npub struct CounterStyleRule {\n name: CustomIdent,\n generation: Wrapping,\n descriptors: Descriptors,\n /// The parser location of the @counter-style rule.\n pub source_location: SourceLocation,\n}\n\n/// Parse the body (inside `{}`) of an @counter-style rule\npub fn parse_counter_style_body<'i, 't>(\n name: CustomIdent,\n context: &ParserContext,\n input: &mut Parser<'i, 't>,\n location: SourceLocation,\n) -> Result> {\n let start = input.current_source_location();\n let mut rule = CounterStyleRule::empty(name, location);\n {\n let mut parser = DescriptorParser {\n context,\n descriptors: &mut rule.descriptors,\n };\n let mut iter = RuleBodyParser::new(input, &mut parser);\n while let Some(declaration) = iter.next() {\n if let Err((error, slice)) = declaration {\n let location = error.location;\n let error = ContextualParseError::UnsupportedCounterStyleDescriptorDeclaration(\n slice, error,\n );\n context.log_css_error(location, error)\n }\n }\n }\n let error = match *rule.resolved_system() {\n ref system @ System::Cyclic\n | ref system @ System::Fixed { .. }\n | ref system @ System::Symbolic\n | ref system @ System::Alphabetic\n | ref system @ System::Numeric\n if rule.descriptors.symbols.is_none() =>\n {\n let system = system.to_css_string();\n Some(ContextualParseError::InvalidCounterStyleWithoutSymbols(\n system,\n ))\n },\n ref system @ System::Alphabetic | ref system @ System::Numeric\n if rule.descriptors.symbols.as_ref().unwrap().0.len() < 2 =>\n {\n let system = system.to_css_string();\n Some(ContextualParseError::InvalidCounterStyleNotEnoughSymbols(\n system,\n ))\n },\n System::Additive if rule.descriptors.additive_symbols.is_none() => {\n Some(ContextualParseError::InvalidCounterStyleWithoutAdditiveSymbols)\n },\n System::Extends(_) if rule.descriptors.symbols.is_some() => {\n Some(ContextualParseError::InvalidCounterStyleExtendsWithSymbols)\n },\n System::Extends(_) if rule.descriptors.additive_symbols.is_some() => {\n Some(ContextualParseError::InvalidCounterStyleExtendsWithAdditiveSymbols)\n },\n _ => None,\n };\n if let Some(error) = error {\n context.log_css_error(start, error);\n Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError))\n } else {\n Ok(rule)\n }\n}\n\nimpl ToCssWithGuard for CounterStyleRule {\n fn to_css(&self, _guard: &SharedRwLockReadGuard, dest: &mut CssStringWriter) -> fmt::Result {\n dest.write_str(\"@counter-style \")?;\n self.name.to_css(&mut CssWriter::new(dest))?;\n dest.write_str(\" { \")?;\n self.descriptors.to_css(&mut CssWriter::new(dest))?;\n dest.write_char('}')\n }\n}\n\n// Implements the special checkers for some setters.\n// See \nimpl CounterStyleRule {\n fn empty(name: CustomIdent, source_location: SourceLocation) -> Self {\n Self {\n name: name,\n generation: Wrapping(0),\n descriptors: Descriptors::default(),\n source_location,\n }\n }\n\n /// Expose the descriptors as read-only, since we rely on updating our generation when they\n /// change, and some setters need extra validation.\n pub fn descriptors(&self) -> &Descriptors {\n &self.descriptors\n }\n\n /// Set a descriptor, with the relevant validation. returns whether the descriptor changed.\n pub fn set_descriptor<'i>(\n &mut self,\n id: DescriptorId,\n context: &ParserContext,\n input: &mut Parser<'i, '_>,\n ) -> Result> {\n // Some descriptors need a couple extra checks, deal with them specially.\n // TODO(emilio): Remove these, see https://github.com/w3c/csswg-drafts/issues/5717\n if id == DescriptorId::AdditiveSymbols\n && matches!(*self.resolved_system(), System::Extends(..))\n {\n // No additive symbols should be set for extends system.\n return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError));\n }\n let changed = match id {\n DescriptorId::System => {\n let system = input.parse_entirely(|i| System::parse(context, i))?;\n if !self.check_system(&system) {\n return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError));\n }\n let new = Some(system);\n if self.descriptors.system == new {\n return Ok(false);\n }\n self.descriptors.system = new;\n true\n },\n DescriptorId::Symbols => {\n let symbols = input.parse_entirely(|i| Symbols::parse(context, i))?;\n if !self.check_symbols(&symbols) {\n return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError));\n }\n let new = Some(symbols);\n if self.descriptors.symbols == new {\n return Ok(false);\n }\n self.descriptors.symbols = new;\n true\n },\n _ => self.descriptors.set(id, context, input)?,\n };\n if changed {\n self.generation += Wrapping(1);\n }\n Ok(changed)\n }\n\n /// Check that the system is effectively not changed. Only params of system descriptor is\n /// changeable.\n fn check_system(&self, value: &System) -> bool {\n mem::discriminant(self.resolved_system()) == mem::discriminant(value)\n }\n\n fn check_symbols(&self, value: &Symbols) -> bool {\n match *self.resolved_system() {\n // These two systems require at least two symbols.\n System::Numeric | System::Alphabetic => value.0.len() >= 2,\n // No symbols should be set for extends system.\n System::Extends(_) => false,\n _ => true,\n }\n }\n\n /// Get the name of the counter style rule.\n pub fn name(&self) -> &CustomIdent {\n &self.name\n }\n\n /// Set the name of the counter style rule. Caller must ensure that\n /// the name is valid.\n pub fn set_name(&mut self, name: CustomIdent) {\n debug_assert!(is_valid_name_definition(&name));\n self.name = name;\n }\n\n /// Get the current generation of the counter style rule.\n pub fn generation(&self) -> u32 {\n self.generation.0\n }\n\n /// Get the system of this counter style rule, default to\n /// `symbolic` if not specified.\n pub fn resolved_system(&self) -> &System {\n match self.descriptors.system {\n Some(ref system) => system,\n None => &System::Symbolic,\n }\n }\n}\n\n/// \n#[derive(Clone, Debug, MallocSizeOf, ToShmem, PartialEq)]\npub enum System {\n /// 'cyclic'\n Cyclic,\n /// 'numeric'\n Numeric,\n /// 'alphabetic'\n Alphabetic,\n /// 'symbolic'\n Symbolic,\n /// 'additive'\n Additive,\n /// 'fixed ?'\n Fixed {\n /// '?'\n first_symbol_value: Option,\n },\n /// 'extends '\n Extends(CustomIdent),\n}\n\nimpl Parse for System {\n fn parse<'i, 't>(\n context: &ParserContext,\n input: &mut Parser<'i, 't>,\n ) -> Result> {\n try_match_ident_ignore_ascii_case! { input,\n \"cyclic\" => Ok(System::Cyclic),\n \"numeric\" => Ok(System::Numeric),\n \"alphabetic\" => Ok(System::Alphabetic),\n \"symbolic\" => Ok(System::Symbolic),\n \"additive\" => Ok(System::Additive),\n \"fixed\" => {\n let first_symbol_value = input.try_parse(|i| Integer::parse(context, i)).ok();\n Ok(System::Fixed { first_symbol_value })\n },\n \"extends\" => {\n let other = parse_counter_style_name(input)?;\n Ok(System::Extends(other))\n },\n }\n }\n}\n\nimpl ToCss for System {\n fn to_css(&self, dest: &mut CssWriter) -> fmt::Result\n where\n W: Write,\n {\n match *self {\n System::Cyclic => dest.write_str(\"cyclic\"),\n System::Numeric => dest.write_str(\"numeric\"),\n System::Alphabetic => dest.write_str(\"alphabetic\"),\n System::Symbolic => dest.write_str(\"symbolic\"),\n System::Additive => dest.write_str(\"additive\"),\n System::Fixed { first_symbol_value } => {\n if let Some(value) = first_symbol_value {\n dest.write_str(\"fixed \")?;\n value.to_css(dest)\n } else {\n dest.write_str(\"fixed\")\n }\n },\n System::Extends(ref other) => {\n dest.write_str(\"extends \")?;\n other.to_css(dest)\n },\n }\n }\n}\n\n/// \n#[derive(\n Clone, Debug, Eq, MallocSizeOf, PartialEq, ToComputedValue, ToResolvedValue, ToCss, ToShmem,\n)]\n#[repr(u8)]\npub enum Symbol {\n /// \n String(crate::OwnedStr),\n /// \n Ident(CustomIdent),\n // Not implemented:\n // /// \n // Image(Image),\n}\n\nimpl Parse for Symbol {\n fn parse<'i, 't>(\n _context: &ParserContext,\n input: &mut Parser<'i, 't>,\n ) -> Result> {\n let location = input.current_source_location();\n match *input.next()? {\n Token::QuotedString(ref s) => Ok(Symbol::String(s.as_ref().to_owned().into())),\n Token::Ident(ref s) => Ok(Symbol::Ident(CustomIdent::from_ident(location, s, &[])?)),\n ref t => Err(location.new_unexpected_token_error(t.clone())),\n }\n }\n}\n\nimpl Symbol {\n /// Returns whether this symbol is allowed in symbols() function.\n pub fn is_allowed_in_symbols(&self) -> bool {\n match self {\n // Identifier is not allowed.\n &Symbol::Ident(_) => false,\n _ => true,\n }\n }\n}\n\n/// \n#[derive(Clone, Debug, MallocSizeOf, ToCss, ToShmem, PartialEq)]\npub struct Negative(pub Symbol, pub Option);\n\nimpl Parse for Negative {\n fn parse<'i, 't>(\n context: &ParserContext,\n input: &mut Parser<'i, 't>,\n ) -> Result> {\n Ok(Negative(\n Symbol::parse(context, input)?,\n input.try_parse(|input| Symbol::parse(context, input)).ok(),\n ))\n }\n}\n\n/// \n#[derive(Clone, Debug, MallocSizeOf, ToCss, ToShmem, PartialEq)]\npub struct CounterRange {\n /// The start of the range.\n pub start: CounterBound,\n /// The end of the range.\n pub end: CounterBound,\n}\n\n/// \n///\n/// Empty represents 'auto'\n#[derive(Clone, Debug, MallocSizeOf, ToCss, ToShmem, PartialEq)]\n#[css(comma)]\npub struct CounterRanges(#[css(iterable, if_empty = \"auto\")] pub crate::OwnedSlice);\n\n/// A bound found in `CounterRanges`.\n#[derive(Clone, Copy, Debug, MallocSizeOf, ToCss, ToShmem, PartialEq)]\npub enum CounterBound {\n /// An integer bound.\n Integer(Integer),\n /// The infinite bound.\n Infinite,\n}\n\nimpl Parse for CounterRanges {\n fn parse<'i, 't>(\n context: &ParserContext,\n input: &mut Parser<'i, 't>,\n ) -> Result> {\n if input\n .try_parse(|input| input.expect_ident_matching(\"auto\"))\n .is_ok()\n {\n return Ok(CounterRanges(Default::default()));\n }\n\n let ranges = input.parse_comma_separated(|input| {\n let start = parse_bound(context, input)?;\n let end = parse_bound(context, input)?;\n if let (CounterBound::Integer(start), CounterBound::Integer(end)) = (start, end) {\n if start > end {\n return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError));\n }\n }\n Ok(CounterRange { start, end })\n })?;\n\n Ok(CounterRanges(ranges.into()))\n }\n}\n\nfn parse_bound<'i, 't>(\n context: &ParserContext,\n input: &mut Parser<'i, 't>,\n) -> Result> {\n if let Ok(integer) = input.try_parse(|input| Integer::parse(context, input)) {\n return Ok(CounterBound::Integer(integer));\n }\n input.expect_ident_matching(\"infinite\")?;\n Ok(CounterBound::Infinite)\n}\n\n/// \n#[derive(Clone, Debug, MallocSizeOf, ToCss, ToShmem, PartialEq)]\npub struct Pad(pub Integer, pub Symbol);\n\nimpl Parse for Pad {\n fn parse<'i, 't>(\n context: &ParserContext,\n input: &mut Parser<'i, 't>,\n ) -> Result> {\n let pad_with = input.try_parse(|input| Symbol::parse(context, input));\n let min_length = Integer::parse_non_negative(context, input)?;\n let pad_with = pad_with.or_else(|_| Symbol::parse(context, input))?;\n Ok(Pad(min_length, pad_with))\n }\n}\n\n/// \n#[derive(Clone, Debug, MallocSizeOf, ToCss, ToShmem, PartialEq)]\npub struct Fallback(pub CustomIdent);\n\nimpl Parse for Fallback {\n fn parse<'i, 't>(\n _context: &ParserContext,\n input: &mut Parser<'i, 't>,\n ) -> Result> {\n Ok(Fallback(parse_counter_style_name(input)?))\n }\n}\n\n/// \n#[derive(\n Clone, Debug, Eq, MallocSizeOf, PartialEq, ToComputedValue, ToResolvedValue, ToCss, ToShmem,\n)]\n#[repr(C)]\npub struct Symbols(\n #[css(iterable)]\n #[ignore_malloc_size_of = \"Arc\"]\n pub crate::ArcSlice,\n);\n\nimpl Parse for Symbols {\n fn parse<'i, 't>(\n context: &ParserContext,\n input: &mut Parser<'i, 't>,\n ) -> Result> {\n let mut symbols = smallvec::SmallVec::<[_; 5]>::new();\n while let Ok(s) = input.try_parse(|input| Symbol::parse(context, input)) {\n symbols.push(s);\n }\n if symbols.is_empty() {\n return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError));\n }\n Ok(Symbols(crate::ArcSlice::from_iter(symbols.drain(..))))\n }\n}\n\n/// \n#[derive(Clone, Debug, MallocSizeOf, ToCss, ToShmem, PartialEq)]\n#[css(comma)]\npub struct AdditiveSymbols(#[css(iterable)] pub crate::OwnedSlice);\n\nimpl Parse for AdditiveSymbols {\n fn parse<'i, 't>(\n context: &ParserContext,\n input: &mut Parser<'i, 't>,\n ) -> Result> {\n let tuples = Vec::::parse(context, input)?;\n // FIXME maybe? https://github.com/w3c/csswg-drafts/issues/1220\n if tuples\n .windows(2)\n .any(|window| window[0].weight <= window[1].weight)\n {\n return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError));\n }\n Ok(AdditiveSymbols(tuples.into()))\n }\n}\n\n/// && \n#[derive(Clone, Debug, MallocSizeOf, ToCss, ToShmem, PartialEq)]\npub struct AdditiveTuple {\n /// \n pub weight: Integer,\n /// \n pub symbol: Symbol,\n}\n\nimpl OneOrMoreSeparated for AdditiveTuple {\n type S = Comma;\n}\n\nimpl Parse for AdditiveTuple {\n fn parse<'i, 't>(\n context: &ParserContext,\n input: &mut Parser<'i, 't>,\n ) -> Result> {\n let symbol = input.try_parse(|input| Symbol::parse(context, input));\n let weight = Integer::parse_non_negative(context, input)?;\n let symbol = symbol.or_else(|_| Symbol::parse(context, input))?;\n Ok(Self { weight, symbol })\n }\n}\n\n/// \n#[derive(Clone, Debug, MallocSizeOf, ToCss, PartialEq, ToShmem)]\npub enum SpeakAs {\n /// auto\n Auto,\n /// bullets\n Bullets,\n /// numbers\n Numbers,\n /// words\n Words,\n // /// spell-out, not supported, see bug 1024178\n // SpellOut,\n /// \n Other(CustomIdent),\n}\n\nimpl Parse for SpeakAs {\n fn parse<'i, 't>(\n _context: &ParserContext,\n input: &mut Parser<'i, 't>,\n ) -> Result> {\n let mut is_spell_out = false;\n let result = input.try_parse(|input| {\n let ident = input.expect_ident().map_err(|_| ())?;\n match_ignore_ascii_case! { &*ident,\n \"auto\" => Ok(SpeakAs::Auto),\n \"bullets\" => Ok(SpeakAs::Bullets),\n \"numbers\" => Ok(SpeakAs::Numbers),\n \"words\" => Ok(SpeakAs::Words),\n \"spell-out\" => {\n is_spell_out = true;\n Err(())\n },\n _ => Err(()),\n }\n });\n if is_spell_out {\n // spell-out is not supported, but don’t parse it as a .\n // See bug 1024178.\n return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError));\n }\n result.or_else(|_| Ok(SpeakAs::Other(parse_counter_style_name(input)?)))\n }\n}\n" }, { "path": "style/counter_style/predefined.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\npredefined! {\n \"decimal\",\n \"decimal-leading-zero\",\n \"arabic-indic\",\n \"armenian\",\n \"upper-armenian\",\n \"lower-armenian\",\n \"bengali\",\n \"cambodian\",\n \"khmer\",\n \"cjk-decimal\",\n \"devanagari\",\n \"georgian\",\n \"gujarati\",\n \"gurmukhi\",\n \"hebrew\",\n \"kannada\",\n \"lao\",\n \"malayalam\",\n \"mongolian\",\n \"myanmar\",\n \"oriya\",\n \"persian\",\n \"lower-roman\",\n \"upper-roman\",\n \"tamil\",\n \"telugu\",\n \"thai\",\n \"tibetan\",\n \"lower-alpha\",\n \"lower-latin\",\n \"upper-alpha\",\n \"upper-latin\",\n \"cjk-earthly-branch\",\n \"cjk-heavenly-stem\",\n \"lower-greek\",\n \"hiragana\",\n \"hiragana-iroha\",\n \"katakana\",\n \"katakana-iroha\",\n \"disc\",\n \"circle\",\n \"square\",\n \"disclosure-open\",\n \"disclosure-closed\",\n \"japanese-informal\",\n \"japanese-formal\",\n \"korean-hangul-formal\",\n \"korean-hanja-informal\",\n \"korean-hanja-formal\",\n \"simp-chinese-informal\",\n \"simp-chinese-formal\",\n \"trad-chinese-informal\",\n \"trad-chinese-formal\",\n \"cjk-ideographic\",\n \"ethiopic-numeric\",\n}\n" }, { "path": "style/counter_style/update_predefined.py", "content": "#!/usr/bin/env python\n\n# This Source Code Form is subject to the terms of the Mozilla Public\n# License, v. 2.0. If a copy of the MPL was not distributed with this\n# file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\nfrom os.path import join, dirname\nimport re\nfrom urllib.request import urlopen\n\n\ndef main(filename):\n names = [\n re.search('>([^>]+)(|\"' in line\n or b'data-dfn-for=\"\"' in line\n ]\n with open(filename, \"w\") as f:\n f.write(\n \"\"\"\\\n/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\npredefined! {\n\"\"\"\n )\n for name in names:\n f.write(' \"%s\",\\n' % name)\n f.write(\"}\\n\")\n\n\nif __name__ == \"__main__\":\n main(join(dirname(__file__), \"predefined.rs\"))\n" }, { "path": "style/custom_properties.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! Support for [custom properties for cascading variables][custom].\n//!\n//! [custom]: https://drafts.csswg.org/css-variables/\n\nuse crate::applicable_declarations::{CascadePriority, RevertKind};\nuse crate::computed_value_flags::ComputedValueFlags;\nuse crate::custom_properties_map::{AllSubstitutionFunctions, CustomPropertiesMap, OwnMap};\nuse crate::device::Device;\nuse crate::dom::AttributeTracker;\nuse crate::properties::{\n CSSWideKeyword, CustomDeclaration, CustomDeclarationValue, LonghandId, LonghandIdSet,\n PropertyDeclaration,\n};\nuse crate::properties_and_values::{\n rule::Descriptors as PropertyDescriptors,\n syntax::{data_type::DependentDataTypes, Descriptor as SyntaxDescriptor},\n value::{\n AllowComputationallyDependent, ComputedValue as ComputedRegisteredValue,\n SpecifiedValue as SpecifiedRegisteredValue,\n },\n};\nuse crate::selector_map::{PrecomputedHashMap, PrecomputedHashSet};\nuse crate::stylesheets::UrlExtraData;\nuse crate::stylist::Stylist;\nuse crate::values::computed::{self, ToComputedValue};\nuse crate::values::generics::calc::SortKey as AttrUnit;\nuse crate::values::specified::FontRelativeLength;\nuse crate::values::specified::ParsedNamespace;\nuse crate::{derives::*, Namespace, Prefix};\nuse crate::{Atom, LocalName};\nuse cssparser::{\n CowRcStr, Delimiter, Parser, ParserInput, SourcePosition, Token, TokenSerializationType,\n};\nuse rustc_hash::FxHashMap;\nuse selectors::parser::SelectorParseErrorKind;\nuse servo_arc::Arc;\nuse smallvec::SmallVec;\nuse std::borrow::Cow;\nuse std::collections::hash_map::Entry;\nuse std::fmt::{self, Write};\nuse std::ops::{Index, IndexMut};\nuse std::{cmp, num};\nuse style_traits::{\n CssString, CssWriter, ParseError, StyleParseErrorKind, ToCss, ToTyped, TypedValue,\n UnparsedSegment, UnparsedValue, VariableReferenceValue,\n};\nuse thin_vec::ThinVec;\n\n/// The environment from which to get `env` function values.\n///\n/// TODO(emilio): If this becomes a bit more complex we should probably move it\n/// to the `media_queries` module, or something.\n#[derive(Debug, MallocSizeOf)]\npub struct CssEnvironment;\n\ntype EnvironmentEvaluator = fn(device: &Device, url_data: &UrlExtraData) -> VariableValue;\n\nstruct EnvironmentVariable {\n name: Atom,\n evaluator: EnvironmentEvaluator,\n}\n\nmacro_rules! make_variable {\n ($name:expr, $evaluator:expr) => {{\n EnvironmentVariable {\n name: $name,\n evaluator: $evaluator,\n }\n }};\n}\n\nfn get_safearea_inset_top(device: &Device, url_data: &UrlExtraData) -> VariableValue {\n VariableValue::pixels(device.safe_area_insets().top, url_data)\n}\n\nfn get_safearea_inset_bottom(device: &Device, url_data: &UrlExtraData) -> VariableValue {\n VariableValue::pixels(device.safe_area_insets().bottom, url_data)\n}\n\nfn get_safearea_inset_left(device: &Device, url_data: &UrlExtraData) -> VariableValue {\n VariableValue::pixels(device.safe_area_insets().left, url_data)\n}\n\nfn get_safearea_inset_right(device: &Device, url_data: &UrlExtraData) -> VariableValue {\n VariableValue::pixels(device.safe_area_insets().right, url_data)\n}\n\n#[cfg(feature = \"gecko\")]\nfn get_content_preferred_color_scheme(device: &Device, url_data: &UrlExtraData) -> VariableValue {\n use crate::queries::values::PrefersColorScheme;\n let prefers_color_scheme = unsafe {\n crate::gecko_bindings::bindings::Gecko_MediaFeatures_PrefersColorScheme(\n device.document(),\n /* use_content = */ true,\n )\n };\n VariableValue::ident(\n match prefers_color_scheme {\n PrefersColorScheme::Light => \"light\",\n PrefersColorScheme::Dark => \"dark\",\n },\n url_data,\n )\n}\n\n#[cfg(feature = \"servo\")]\nfn get_content_preferred_color_scheme(_device: &Device, url_data: &UrlExtraData) -> VariableValue {\n // TODO: Add an implementation for Servo.\n VariableValue::ident(\"light\", url_data)\n}\n\nfn get_scrollbar_inline_size(device: &Device, url_data: &UrlExtraData) -> VariableValue {\n VariableValue::pixels(device.scrollbar_inline_size().px(), url_data)\n}\n\nfn get_hairline(device: &Device, url_data: &UrlExtraData) -> VariableValue {\n VariableValue::pixels(\n app_units::Au(device.app_units_per_device_pixel()).to_f32_px(),\n url_data,\n )\n}\n\nstatic ENVIRONMENT_VARIABLES: [EnvironmentVariable; 4] = [\n make_variable!(atom!(\"safe-area-inset-top\"), get_safearea_inset_top),\n make_variable!(atom!(\"safe-area-inset-bottom\"), get_safearea_inset_bottom),\n make_variable!(atom!(\"safe-area-inset-left\"), get_safearea_inset_left),\n make_variable!(atom!(\"safe-area-inset-right\"), get_safearea_inset_right),\n];\n\n#[cfg(feature = \"gecko\")]\nmacro_rules! lnf_int {\n ($id:ident) => {\n unsafe {\n crate::gecko_bindings::bindings::Gecko_GetLookAndFeelInt(\n crate::gecko_bindings::bindings::LookAndFeel_IntID::$id as i32,\n )\n }\n };\n}\n\n#[cfg(feature = \"servo\")]\nmacro_rules! lnf_int {\n ($id:ident) => {\n // TODO: Add an implementation for Servo.\n 0\n };\n}\n\nmacro_rules! lnf_int_variable {\n ($atom:expr, $id:ident, $ctor:ident) => {{\n fn __eval(_: &Device, url_data: &UrlExtraData) -> VariableValue {\n VariableValue::$ctor(lnf_int!($id), url_data)\n }\n make_variable!($atom, __eval)\n }};\n}\n\nfn eval_gtk_csd_titlebar_radius(device: &Device, url_data: &UrlExtraData) -> VariableValue {\n let int_pixels = lnf_int!(TitlebarRadius);\n let unzoomed_scale =\n device.device_pixel_ratio_ignoring_full_zoom().get() / device.device_pixel_ratio().get();\n VariableValue::pixels(int_pixels as f32 * unzoomed_scale, url_data)\n}\n\nstatic CHROME_ENVIRONMENT_VARIABLES: [EnvironmentVariable; 9] = [\n make_variable!(\n atom!(\"-moz-gtk-csd-titlebar-radius\"),\n eval_gtk_csd_titlebar_radius\n ),\n lnf_int_variable!(\n atom!(\"-moz-gtk-csd-tooltip-radius\"),\n TooltipRadius,\n int_pixels\n ),\n lnf_int_variable!(\n atom!(\"-moz-gtk-csd-close-button-position\"),\n GTKCSDCloseButtonPosition,\n integer\n ),\n lnf_int_variable!(\n atom!(\"-moz-gtk-csd-minimize-button-position\"),\n GTKCSDMinimizeButtonPosition,\n integer\n ),\n lnf_int_variable!(\n atom!(\"-moz-gtk-csd-maximize-button-position\"),\n GTKCSDMaximizeButtonPosition,\n integer\n ),\n lnf_int_variable!(\n atom!(\"-moz-overlay-scrollbar-fade-duration\"),\n ScrollbarFadeDuration,\n int_ms\n ),\n make_variable!(\n atom!(\"-moz-content-preferred-color-scheme\"),\n get_content_preferred_color_scheme\n ),\n make_variable!(atom!(\"scrollbar-inline-size\"), get_scrollbar_inline_size),\n make_variable!(atom!(\"hairline\"), get_hairline),\n];\n\nimpl CssEnvironment {\n #[inline]\n fn get(&self, name: &Atom, device: &Device, url_data: &UrlExtraData) -> Option {\n if let Some(var) = ENVIRONMENT_VARIABLES.iter().find(|var| var.name == *name) {\n return Some((var.evaluator)(device, url_data));\n }\n if !url_data.chrome_rules_enabled() {\n return None;\n }\n let var = CHROME_ENVIRONMENT_VARIABLES\n .iter()\n .find(|var| var.name == *name)?;\n Some((var.evaluator)(device, url_data))\n }\n}\n\n/// A custom property name is just an `Atom`.\n///\n/// Note that this does not include the `--` prefix\npub type Name = Atom;\n\n/// Parse a custom property name.\n///\n/// \npub fn parse_name(s: &str) -> Result<&str, ()> {\n if s.starts_with(\"--\") && s.len() > 2 {\n Ok(&s[2..])\n } else {\n Err(())\n }\n}\n\n/// A value for a custom property is just a set of tokens.\n///\n/// We preserve the original CSS for serialization, and also the variable\n/// references to other custom property names.\n#[derive(Clone, Debug, MallocSizeOf, ToShmem)]\npub struct VariableValue {\n /// The raw CSS string.\n pub css: String,\n\n /// The url data of the stylesheet where this value came from.\n pub url_data: UrlExtraData,\n\n first_token_type: TokenSerializationType,\n last_token_type: TokenSerializationType,\n\n /// var(), env(), attr() or non-custom property (e.g. through `em`) references.\n references: References,\n}\n\ntrivial_to_computed_value!(VariableValue);\n\n/// Given a potentially registered variable value turn it into a computed custom property value.\npub fn compute_variable_value(\n value: &Arc,\n registration: &PropertyDescriptors,\n computed_context: &computed::Context,\n) -> Option {\n if registration.is_universal() {\n return Some(ComputedRegisteredValue::universal(Arc::clone(value)));\n }\n compute_value(\n &value.css,\n &value.url_data,\n registration,\n computed_context,\n AttrTaint::default(),\n )\n .ok()\n}\n\n// For all purposes, we want values to be considered equal if their css text is equal.\nimpl PartialEq for VariableValue {\n fn eq(&self, other: &Self) -> bool {\n self.css == other.css\n }\n}\n\nimpl Eq for VariableValue {}\n\nimpl ToCss for SpecifiedValue {\n fn to_css(&self, dest: &mut CssWriter) -> fmt::Result\n where\n W: Write,\n {\n dest.write_str(&self.css)\n }\n}\n\nimpl ToTyped for SpecifiedValue {\n fn to_typed(&self, dest: &mut ThinVec) -> Result<(), ()> {\n let unparsed_value = reify_variable_value(self)?;\n dest.push(TypedValue::Unparsed(unparsed_value));\n Ok(())\n }\n}\n\nfn reify_variable_value(value: &VariableValue) -> Result {\n let mut reference_index = 0;\n reify_variable_value_range(\n &value.css,\n &value.references.refs,\n &mut reference_index,\n 0,\n value.css.len(),\n )\n}\n\n/// Reify a slice of the CSS string into UnparsedSegment entries.\n///\n/// References are stored in source order, with outer substitution functions\n/// inserted before references in their fallback. The shared `reference_index`\n/// relies on this ordering to recurse into fallbacks without reprocessing\n/// nested referecences.\nfn reify_variable_value_range(\n css: &str,\n references: &[SubstitutionFunctionReference],\n reference_index: &mut usize,\n start: usize,\n end: usize,\n) -> Result {\n debug_assert!(start <= end);\n debug_assert!(end <= css.len());\n\n let mut values = ThinVec::new();\n let mut cur_pos = start;\n\n while *reference_index < references.len() {\n let reference = &references[*reference_index];\n\n if reference.start >= end {\n break;\n }\n\n debug_assert!(reference.start >= cur_pos);\n debug_assert!(reference.start <= reference.end);\n debug_assert!(reference.end <= css.len());\n\n if cur_pos < reference.start {\n values.push(UnparsedSegment::String(CssString::from(\n &css[cur_pos..reference.start],\n )));\n }\n\n *reference_index += 1;\n\n if reference.substitution_kind != SubstitutionFunctionKind::Var {\n return Err(());\n }\n\n let (fallback, has_fallback) = if let Some(fallback) = &reference.fallback {\n debug_assert!(fallback.start.get() <= reference.end - 1);\n\n (\n reify_variable_value_range(\n css,\n references,\n reference_index,\n fallback.start.get(),\n reference.end - 1, // Skip the closing ')'.\n )?,\n true,\n )\n } else {\n (ThinVec::new(), false)\n };\n\n values.push(UnparsedSegment::VariableReference(VariableReferenceValue {\n variable: CssString::from(format!(\"--{}\", reference.name)),\n fallback,\n has_fallback,\n }));\n\n cur_pos = reference.end;\n }\n\n if cur_pos < end {\n values.push(UnparsedSegment::String(CssString::from(&css[cur_pos..end])));\n }\n\n Ok(values)\n}\n\n/// A pair of separate CustomPropertiesMaps, split between custom properties\n/// that have the inherit flag set and those with the flag unset.\n#[repr(C)]\n#[derive(Clone, Debug, Default, PartialEq)]\npub struct ComputedCustomProperties {\n /// Map for custom properties with inherit flag set, including non-registered\n /// ones.\n pub inherited: CustomPropertiesMap,\n /// Map for custom properties with inherit flag unset.\n pub non_inherited: CustomPropertiesMap,\n}\n\nimpl ComputedCustomProperties {\n /// Return whether the inherited and non_inherited maps are none.\n pub fn is_empty(&self) -> bool {\n self.inherited.is_empty() && self.non_inherited.is_empty()\n }\n\n /// Return the name and value of the property at specified index, if any.\n pub fn property_at(&self, index: usize) -> Option<(&Name, &Option)> {\n // Just expose the custom property items from custom_properties.inherited, followed\n // by custom property items from custom_properties.non_inherited.\n self.inherited\n .get_index(index)\n .or_else(|| self.non_inherited.get_index(index - self.inherited.len()))\n }\n\n /// Insert a custom property in the corresponding inherited/non_inherited\n /// map, depending on whether the inherit flag is set or unset.\n pub(crate) fn insert(\n &mut self,\n registration: &PropertyDescriptors,\n name: &Name,\n value: ComputedRegisteredValue,\n ) {\n self.map_mut(registration).insert(name, value)\n }\n\n /// Remove a custom property from the corresponding inherited/non_inherited\n /// map, depending on whether the inherit flag is set or unset.\n pub(crate) fn remove(&mut self, registration: &PropertyDescriptors, name: &Name) {\n self.map_mut(registration).remove(name);\n }\n\n /// Shrink the capacity of the inherited maps as much as possible.\n fn shrink_to_fit(&mut self) {\n self.inherited.shrink_to_fit();\n self.non_inherited.shrink_to_fit();\n }\n\n fn map_mut(&mut self, registration: &PropertyDescriptors) -> &mut CustomPropertiesMap {\n if registration.inherits() {\n &mut self.inherited\n } else {\n &mut self.non_inherited\n }\n }\n\n /// Returns the relevant custom property value given a registration.\n pub fn get(\n &self,\n registration: &PropertyDescriptors,\n name: &Name,\n ) -> Option<&ComputedRegisteredValue> {\n if registration.inherits() {\n self.inherited.get(name)\n } else {\n self.non_inherited.get(name)\n }\n }\n}\n\n/// Both specified and computed values are VariableValues, the difference is\n/// whether var() functions are expanded.\npub type SpecifiedValue = VariableValue;\n/// Both specified and computed values are VariableValues, the difference is\n/// whether var() functions are expanded.\npub type ComputedValue = VariableValue;\n\n/// Set of flags to non-custom references this custom property makes.\n#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, MallocSizeOf, ToShmem)]\nstruct NonCustomReferences(u8);\n\nbitflags! {\n impl NonCustomReferences: u8 {\n /// At least one custom property depends on font-relative units.\n const FONT_UNITS = 1 << 0;\n /// At least one custom property depends on root element's font-relative units.\n const ROOT_FONT_UNITS = 1 << 1;\n /// At least one custom property depends on line height units.\n const LH_UNITS = 1 << 2;\n /// At least one custom property depends on root element's line height units.\n const ROOT_LH_UNITS = 1 << 3;\n /// All dependencies not depending on the root element.\n const NON_ROOT_DEPENDENCIES = Self::FONT_UNITS.0 | Self::LH_UNITS.0;\n /// All dependencies depending on the root element.\n const ROOT_DEPENDENCIES = Self::ROOT_FONT_UNITS.0 | Self::ROOT_LH_UNITS.0;\n }\n}\n\nimpl NonCustomReferences {\n fn for_each(&self, mut f: F)\n where\n F: FnMut(SingleNonCustomReference),\n {\n for (_, r) in self.iter_names() {\n let single = match r {\n Self::FONT_UNITS => SingleNonCustomReference::FontUnits,\n Self::ROOT_FONT_UNITS => SingleNonCustomReference::RootFontUnits,\n Self::LH_UNITS => SingleNonCustomReference::LhUnits,\n Self::ROOT_LH_UNITS => SingleNonCustomReference::RootLhUnits,\n _ => unreachable!(\"Unexpected single bit value\"),\n };\n f(single);\n }\n }\n\n fn from_unit(value: &CowRcStr) -> Self {\n // For registered properties, any reference to font-relative dimensions\n // make it dependent on font-related properties.\n // TODO(dshin): When we unit algebra gets implemented and handled -\n // Is it valid to say that `calc(1em / 2em * 3px)` triggers this?\n if value.eq_ignore_ascii_case(FontRelativeLength::LH) {\n return Self::FONT_UNITS | Self::LH_UNITS;\n }\n if value.eq_ignore_ascii_case(FontRelativeLength::EM)\n || value.eq_ignore_ascii_case(FontRelativeLength::EX)\n || value.eq_ignore_ascii_case(FontRelativeLength::CAP)\n || value.eq_ignore_ascii_case(FontRelativeLength::CH)\n || value.eq_ignore_ascii_case(FontRelativeLength::IC)\n {\n return Self::FONT_UNITS;\n }\n if value.eq_ignore_ascii_case(FontRelativeLength::RLH) {\n return Self::ROOT_FONT_UNITS | Self::ROOT_LH_UNITS;\n }\n if value.eq_ignore_ascii_case(FontRelativeLength::REM)\n || value.eq_ignore_ascii_case(FontRelativeLength::REX)\n || value.eq_ignore_ascii_case(FontRelativeLength::RCH)\n || value.eq_ignore_ascii_case(FontRelativeLength::RCAP)\n || value.eq_ignore_ascii_case(FontRelativeLength::RIC)\n {\n return Self::ROOT_FONT_UNITS;\n }\n Self::empty()\n }\n}\n\n#[derive(Clone, Copy, Debug, Eq, PartialEq)]\nenum SingleNonCustomReference {\n FontUnits = 0,\n RootFontUnits,\n LhUnits,\n RootLhUnits,\n}\n\nstruct NonCustomReferenceMap([Option; 4]);\n\nimpl Default for NonCustomReferenceMap {\n fn default() -> Self {\n NonCustomReferenceMap(Default::default())\n }\n}\n\nimpl Index for NonCustomReferenceMap {\n type Output = Option;\n\n fn index(&self, reference: SingleNonCustomReference) -> &Self::Output {\n &self.0[reference as usize]\n }\n}\n\nimpl IndexMut for NonCustomReferenceMap {\n fn index_mut(&mut self, reference: SingleNonCustomReference) -> &mut Self::Output {\n &mut self.0[reference as usize]\n }\n}\n\n/// Whether to defer resolving custom properties referencing font relative units.\n#[derive(Clone, Copy, PartialEq, Eq)]\n#[allow(missing_docs)]\npub enum DeferFontRelativeCustomPropertyResolution {\n Yes,\n No,\n}\n\n/// Substitution function source: var, env, attr.\n#[derive(Copy, Clone, Debug, MallocSizeOf, Hash, Eq, PartialEq, ToShmem, Parse)]\npub enum SubstitutionFunctionKind {\n /// CSS variable / custom property\n Var,\n /// Environment variable\n Env,\n /// DOM attribute\n Attr,\n}\n\n/// A wrapper map that encapsulates both the custom properties and attributes\n/// for a given element.\n#[repr(C)]\n#[derive(Clone, Debug, Default, PartialEq)]\npub struct ComputedSubstitutionFunctions {\n /// The applicable custom properties (includes inherited and non-inherited).\n pub custom_properties: ComputedCustomProperties,\n /// The applicable DOM attributes.\n pub attributes: OwnMap,\n}\n\nimpl ComputedSubstitutionFunctions {\n /// Creates a substitution function map from optional custom properties\n /// and DOM attributes.\n #[inline(always)]\n pub fn new(\n custom_properties: Option,\n attributes: Option,\n ) -> Self {\n Self {\n custom_properties: custom_properties.unwrap_or_default(),\n attributes: attributes.unwrap_or_default(),\n }\n }\n\n #[inline(always)]\n fn insert_var(\n &mut self,\n registration: &PropertyDescriptors,\n name: &Name,\n value: ComputedRegisteredValue,\n ) {\n self.custom_properties.insert(registration, name, value);\n }\n\n #[inline(always)]\n fn insert_attr(&mut self, name: &Name, value: ComputedRegisteredValue) {\n self.attributes.insert(name.clone(), Some(value));\n }\n\n #[inline(always)]\n fn remove_var(&mut self, registration: &PropertyDescriptors, name: &Name) {\n self.custom_properties.remove(registration, name);\n }\n\n #[inline(always)]\n fn remove_attr(&mut self, name: &Name) {\n self.attributes.insert(name.clone(), None);\n }\n\n #[inline(always)]\n fn get_var(\n &self,\n registration: &PropertyDescriptors,\n name: &Name,\n ) -> Option<&ComputedRegisteredValue> {\n self.custom_properties.get(registration, name)\n }\n\n #[inline(always)]\n fn get_attr(&self, name: &Name) -> Option<&ComputedRegisteredValue> {\n self.attributes.get(name).and_then(|p| p.as_ref())\n }\n}\n\n#[derive(Clone, Debug, MallocSizeOf, PartialEq, ToShmem, Parse)]\nenum AttributeType {\n None,\n RawString,\n Type(SyntaxDescriptor),\n Unit(AttrUnit),\n}\n\n#[derive(Clone, Debug, MallocSizeOf, PartialEq, ToShmem)]\nstruct AttributeData {\n kind: AttributeType,\n namespace: ParsedNamespace,\n}\n\n/// For a CSS string, the range, counted in bytes, that is attr()-tainted.\n#[derive(Clone, Debug, Default, MallocSizeOf, PartialEq, ToShmem, ToComputedValue)]\npub struct AttrTaintedRange {\n /// Start of the range, counted in bytes. Inclusive.\n start: usize,\n /// End of the range, counted in bytes. Exclusive.\n end: usize,\n}\n\nimpl AttrTaintedRange {\n /// Creates a range within a CSS string that is tainted by attr().\n #[inline(always)]\n pub fn new(start: usize, end: usize) -> Self {\n debug_assert!(start <= end);\n Self { start, end }\n }\n}\n\n/// In CSS Values and Units, values produced by `attr()` are considered attr()-tainted, as are\n/// functions that contain an attr()-tainted value. Using an attr()-tainted value as or in a \n/// makes a declaration invalid at computed-value time.\n/// https://drafts.csswg.org/css-values-5/#attr-security\n#[derive(Clone, Debug, Default, MallocSizeOf, PartialEq, ToShmem)]\npub struct AttrTaint(SmallVec<[AttrTaintedRange; 1]>);\n\nimpl AttrTaint {\n /// For a CSS string, determine whether any `` overlapping this `range`\n /// is disallowed due to attr()-tainting.\n #[inline(always)]\n pub fn should_disallow_urls_in_range(&self, range: &AttrTaintedRange) -> bool {\n self.0\n .iter()\n .any(|r| r.start <= range.end && r.end >= range.start)\n }\n\n /// Returns true if the attr()-tainted range contains no elements.\n #[inline(always)]\n pub fn is_empty(&self) -> bool {\n self.0.is_empty()\n }\n\n #[inline(always)]\n fn new_fully_tainted(end: usize) -> Self {\n let mut taint = Self::default();\n taint.push(0, end);\n taint\n }\n\n #[inline(always)]\n fn push(&mut self, start: usize, end: usize) {\n self.0.push(AttrTaintedRange::new(start, end));\n }\n}\n\n#[derive(Clone, Debug, MallocSizeOf, PartialEq, ToShmem)]\nstruct VariableFallback {\n // NOTE(emilio): We don't track fallback end, because we rely on the missing closing\n // parenthesis, if any, to be inserted, which means that we can rely on our end being\n // reference.end - 1.\n start: num::NonZeroUsize,\n first_token_type: TokenSerializationType,\n last_token_type: TokenSerializationType,\n}\n\n#[derive(Clone, Debug, MallocSizeOf, PartialEq, ToShmem)]\nstruct SubstitutionFunctionReference {\n name: Name,\n start: usize,\n end: usize,\n fallback: Option,\n attribute_data: AttributeData,\n prev_token_type: TokenSerializationType,\n next_token_type: TokenSerializationType,\n substitution_kind: SubstitutionFunctionKind,\n}\n\n/// A struct holding information about the external references to that a custom\n/// property value may have.\n#[derive(Clone, Debug, Default, MallocSizeOf, PartialEq, ToShmem)]\nstruct References {\n refs: Vec,\n non_custom_references: NonCustomReferences,\n any_env: bool,\n any_var: bool,\n any_attr: bool,\n}\n\nimpl References {\n fn has_references(&self) -> bool {\n !self.refs.is_empty()\n }\n\n fn non_custom_references(&self, is_root_element: bool) -> NonCustomReferences {\n let mut mask = NonCustomReferences::NON_ROOT_DEPENDENCIES;\n if is_root_element {\n mask |= NonCustomReferences::ROOT_DEPENDENCIES\n }\n self.non_custom_references & mask\n }\n}\n\nimpl VariableValue {\n fn empty(url_data: &UrlExtraData) -> Self {\n Self {\n css: String::new(),\n last_token_type: Default::default(),\n first_token_type: Default::default(),\n url_data: url_data.clone(),\n references: Default::default(),\n }\n }\n\n /// Create a new custom property without parsing if the CSS is known to be valid and contain no\n /// references.\n pub fn new(\n css: String,\n url_data: &UrlExtraData,\n first_token_type: TokenSerializationType,\n last_token_type: TokenSerializationType,\n ) -> Self {\n Self {\n css,\n url_data: url_data.clone(),\n first_token_type,\n last_token_type,\n references: References::default(),\n }\n }\n\n fn push<'i>(\n &mut self,\n css: &str,\n css_first_token_type: TokenSerializationType,\n css_last_token_type: TokenSerializationType,\n attr_taint: Option<&mut AttrTaint>,\n ) -> Result<(), ()> {\n /// Prevent values from getting terribly big since you can use custom\n /// properties exponentially.\n ///\n /// This number (2MB) is somewhat arbitrary, but silly enough that no\n /// reasonable page should hit it. We could limit by number of total\n /// substitutions, but that was very easy to work around in practice\n /// (just choose a larger initial value and boom).\n const MAX_VALUE_LENGTH_IN_BYTES: usize = 2 * 1024 * 1024;\n\n if self.css.len() + css.len() > MAX_VALUE_LENGTH_IN_BYTES {\n return Err(());\n }\n\n // This happens e.g. between two subsequent var() functions:\n // `var(--a)var(--b)`.\n //\n // In that case, css_*_token_type is nonsensical.\n if css.is_empty() {\n return Ok(());\n }\n\n self.first_token_type.set_if_nothing(css_first_token_type);\n // If self.first_token_type was nothing,\n // self.last_token_type is also nothing and this will be false:\n if self\n .last_token_type\n .needs_separator_when_before(css_first_token_type)\n {\n self.css.push_str(\"/**/\")\n }\n let start = self.css.len();\n self.css.push_str(css);\n let end = self.css.len();\n if let Some(taint) = attr_taint {\n taint.push(start, end);\n }\n self.last_token_type = css_last_token_type;\n Ok(())\n }\n\n /// Parse a custom property value.\n pub fn parse<'i, 't>(\n input: &mut Parser<'i, 't>,\n namespaces: Option<&FxHashMap>,\n url_data: &UrlExtraData,\n ) -> Result> {\n let mut references = References::default();\n let mut missing_closing_characters = String::new();\n let start_position = input.position();\n let (first_token_type, last_token_type) = parse_declaration_value(\n input,\n start_position,\n namespaces,\n &mut references,\n &mut missing_closing_characters,\n )?;\n let mut css = input\n .slice_from(start_position)\n .trim_ascii_start()\n .to_owned();\n if !missing_closing_characters.is_empty() {\n // Unescaped backslash at EOF in a quoted string is ignored.\n if css.ends_with(\"\\\\\")\n && matches!(missing_closing_characters.as_bytes()[0], b'\"' | b'\\'')\n {\n css.pop();\n }\n css.push_str(&missing_closing_characters);\n }\n\n css.truncate(css.trim_ascii_end().len());\n css.shrink_to_fit();\n references.refs.shrink_to_fit();\n\n Ok(Self {\n css,\n url_data: url_data.clone(),\n first_token_type,\n last_token_type,\n references,\n })\n }\n\n /// Returns whether this value is tainted by `attr()`.\n pub fn is_attr_tainted(&self) -> bool {\n self.references.any_attr\n }\n\n /// Create VariableValue from an int.\n fn integer(number: i32, url_data: &UrlExtraData) -> Self {\n Self::from_token(\n Token::Number {\n has_sign: false,\n value: number as f32,\n int_value: Some(number),\n },\n url_data,\n )\n }\n\n /// Create VariableValue from an int.\n fn ident(ident: &'static str, url_data: &UrlExtraData) -> Self {\n Self::from_token(Token::Ident(ident.into()), url_data)\n }\n\n /// Create VariableValue from a float amount of CSS pixels.\n fn pixels(number: f32, url_data: &UrlExtraData) -> Self {\n // FIXME (https://github.com/servo/rust-cssparser/issues/266):\n // No way to get TokenSerializationType::Dimension without creating\n // Token object.\n Self::from_token(\n Token::Dimension {\n has_sign: false,\n value: number,\n int_value: None,\n unit: CowRcStr::from(\"px\"),\n },\n url_data,\n )\n }\n\n /// Create VariableValue from an integer amount of milliseconds.\n fn int_ms(number: i32, url_data: &UrlExtraData) -> Self {\n Self::from_token(\n Token::Dimension {\n has_sign: false,\n value: number as f32,\n int_value: Some(number),\n unit: CowRcStr::from(\"ms\"),\n },\n url_data,\n )\n }\n\n /// Create VariableValue from an integer amount of CSS pixels.\n fn int_pixels(number: i32, url_data: &UrlExtraData) -> Self {\n Self::from_token(\n Token::Dimension {\n has_sign: false,\n value: number as f32,\n int_value: Some(number),\n unit: CowRcStr::from(\"px\"),\n },\n url_data,\n )\n }\n\n fn from_token(token: Token, url_data: &UrlExtraData) -> Self {\n let token_type = token.serialization_type();\n let mut css = token.to_css_string();\n css.shrink_to_fit();\n\n VariableValue {\n css,\n url_data: url_data.clone(),\n first_token_type: token_type,\n last_token_type: token_type,\n references: Default::default(),\n }\n }\n\n /// Returns the raw CSS text from this VariableValue\n pub fn css_text(&self) -> &str {\n &self.css\n }\n\n /// Returns whether this variable value has any reference to the environment or other\n /// variables.\n pub fn has_references(&self) -> bool {\n self.references.has_references()\n }\n}\n\n/// \nfn parse_declaration_value<'i, 't>(\n input: &mut Parser<'i, 't>,\n input_start: SourcePosition,\n namespaces: Option<&FxHashMap>,\n references: &mut References,\n missing_closing_characters: &mut String,\n) -> Result<(TokenSerializationType, TokenSerializationType), ParseError<'i>> {\n input.parse_until_before(Delimiter::Bang | Delimiter::Semicolon, |input| {\n parse_declaration_value_block(\n input,\n input_start,\n namespaces,\n references,\n missing_closing_characters,\n )\n })\n}\n\n/// Like parse_declaration_value, but accept `!` and `;` since they are only invalid at the top level.\nfn parse_declaration_value_block<'i, 't>(\n input: &mut Parser<'i, 't>,\n input_start: SourcePosition,\n namespaces: Option<&FxHashMap>,\n references: &mut References,\n missing_closing_characters: &mut String,\n) -> Result<(TokenSerializationType, TokenSerializationType), ParseError<'i>> {\n let mut is_first = true;\n let mut first_token_type = TokenSerializationType::Nothing;\n let mut last_token_type = TokenSerializationType::Nothing;\n let mut prev_reference_index: Option = None;\n loop {\n let token_start = input.position();\n let Ok(token) = input.next_including_whitespace_and_comments() else {\n break;\n };\n\n let prev_token_type = last_token_type;\n let serialization_type = token.serialization_type();\n last_token_type = serialization_type;\n if is_first {\n first_token_type = last_token_type;\n is_first = false;\n }\n\n macro_rules! nested {\n ($closing:expr) => {{\n let mut inner_end_position = None;\n let result = input.parse_nested_block(|input| {\n let result = parse_declaration_value_block(\n input,\n input_start,\n namespaces,\n references,\n missing_closing_characters,\n )?;\n inner_end_position = Some(input.position());\n Ok(result)\n })?;\n if inner_end_position.unwrap() == input.position() {\n missing_closing_characters.push_str($closing);\n }\n result\n }};\n }\n if let Some(index) = prev_reference_index.take() {\n references.refs[index].next_token_type = serialization_type;\n }\n match *token {\n Token::Comment(_) => {\n let token_slice = input.slice_from(token_start);\n if !token_slice.ends_with(\"*/\") {\n missing_closing_characters.push_str(if token_slice.ends_with('*') {\n \"/\"\n } else {\n \"*/\"\n })\n }\n },\n Token::BadUrl(ref u) => {\n let e = StyleParseErrorKind::BadUrlInDeclarationValueBlock(u.clone());\n return Err(input.new_custom_error(e));\n },\n Token::BadString(ref s) => {\n let e = StyleParseErrorKind::BadStringInDeclarationValueBlock(s.clone());\n return Err(input.new_custom_error(e));\n },\n Token::CloseParenthesis => {\n let e = StyleParseErrorKind::UnbalancedCloseParenthesisInDeclarationValueBlock;\n return Err(input.new_custom_error(e));\n },\n Token::CloseSquareBracket => {\n let e = StyleParseErrorKind::UnbalancedCloseSquareBracketInDeclarationValueBlock;\n return Err(input.new_custom_error(e));\n },\n Token::CloseCurlyBracket => {\n let e = StyleParseErrorKind::UnbalancedCloseCurlyBracketInDeclarationValueBlock;\n return Err(input.new_custom_error(e));\n },\n Token::Function(ref name) => {\n let substitution_kind = match SubstitutionFunctionKind::from_ident(name).ok() {\n Some(SubstitutionFunctionKind::Attr) => {\n if static_prefs::pref!(\"layout.css.attr.enabled\") {\n Some(SubstitutionFunctionKind::Attr)\n } else {\n None\n }\n },\n kind => kind,\n };\n if let Some(substitution_kind) = substitution_kind {\n let our_ref_index = references.refs.len();\n let mut input_end_position = None;\n let fallback = input.parse_nested_block(|input| {\n let mut namespace = ParsedNamespace::Known(Namespace::default());\n if substitution_kind == SubstitutionFunctionKind::Attr {\n if let Some(namespaces) = namespaces {\n if let Ok(ns) = input\n .try_parse(|input| ParsedNamespace::parse(namespaces, input))\n {\n namespace = ns;\n }\n }\n }\n // TODO(emilio): For env() this should be per spec, but no other browser does\n // that, see https://github.com/w3c/csswg-drafts/issues/3262.\n let name = input.expect_ident()?;\n let name =\n Atom::from(if substitution_kind == SubstitutionFunctionKind::Var {\n match parse_name(name.as_ref()) {\n Ok(name) => name,\n Err(()) => {\n let name = name.clone();\n return Err(input.new_custom_error(\n SelectorParseErrorKind::UnexpectedIdent(name),\n ));\n },\n }\n } else {\n name.as_ref()\n });\n\n let attribute_kind = if substitution_kind == SubstitutionFunctionKind::Attr\n {\n parse_attr_type(input)\n } else {\n AttributeType::None\n };\n\n // We want the order of the references to match source order. So we need to reserve our slot\n // now, _before_ parsing our fallback. Note that we don't care if parsing fails after all, since\n // if this fails we discard the whole result anyways.\n let start = token_start.byte_index() - input_start.byte_index();\n references.refs.push(SubstitutionFunctionReference {\n name,\n start,\n // To be fixed up after parsing fallback and auto-closing via our_ref_index.\n end: start,\n prev_token_type,\n // To be fixed up (if needed) on the next loop iteration via prev_reference_index.\n next_token_type: TokenSerializationType::Nothing,\n // To be fixed up after parsing fallback.\n fallback: None,\n attribute_data: AttributeData {\n kind: attribute_kind,\n namespace,\n },\n substitution_kind: substitution_kind.clone(),\n });\n\n let mut fallback = None;\n if input.try_parse(|input| input.expect_comma()).is_ok() {\n input.skip_whitespace();\n let fallback_start = num::NonZeroUsize::new(\n input.position().byte_index() - input_start.byte_index(),\n )\n .unwrap();\n // NOTE(emilio): Intentionally using parse_declaration_value rather than\n // parse_declaration_value_block, since that's what parse_fallback used to do.\n let (first, last) = parse_declaration_value(\n input,\n input_start,\n namespaces,\n references,\n missing_closing_characters,\n )?;\n fallback = Some(VariableFallback {\n start: fallback_start,\n first_token_type: first,\n last_token_type: last,\n });\n input_end_position = Some(input.position());\n } else {\n let state = input.state();\n // We still need to consume the rest of the potentially-unclosed\n // tokens, but make sure to not consume tokens that would otherwise be\n // invalid, by calling reset().\n parse_declaration_value_block(\n input,\n input_start,\n namespaces,\n references,\n missing_closing_characters,\n )?;\n input_end_position = Some(input.position());\n input.reset(&state);\n }\n Ok(fallback)\n })?;\n if input_end_position.unwrap() == input.position() {\n missing_closing_characters.push_str(\")\");\n }\n prev_reference_index = Some(our_ref_index);\n let reference = &mut references.refs[our_ref_index];\n reference.end = input.position().byte_index() - input_start.byte_index()\n + missing_closing_characters.len();\n reference.fallback = fallback;\n match substitution_kind {\n SubstitutionFunctionKind::Var => references.any_var = true,\n SubstitutionFunctionKind::Env => references.any_env = true,\n SubstitutionFunctionKind::Attr => references.any_attr = true,\n };\n } else {\n nested!(\")\");\n }\n },\n Token::ParenthesisBlock => {\n nested!(\")\");\n },\n Token::CurlyBracketBlock => {\n nested!(\"}\");\n },\n Token::SquareBracketBlock => {\n nested!(\"]\");\n },\n Token::QuotedString(_) => {\n let token_slice = input.slice_from(token_start);\n let quote = &token_slice[..1];\n debug_assert!(matches!(quote, \"\\\"\" | \"'\"));\n if !(token_slice.ends_with(quote) && token_slice.len() > 1) {\n missing_closing_characters.push_str(quote)\n }\n },\n Token::Ident(ref value)\n | Token::AtKeyword(ref value)\n | Token::Hash(ref value)\n | Token::IDHash(ref value)\n | Token::UnquotedUrl(ref value)\n | Token::Dimension {\n unit: ref value, ..\n } => {\n references\n .non_custom_references\n .insert(NonCustomReferences::from_unit(value));\n let is_unquoted_url = matches!(token, Token::UnquotedUrl(_));\n if value.ends_with(\"�\") && input.slice_from(token_start).ends_with(\"\\\\\") {\n // Unescaped backslash at EOF in these contexts is interpreted as U+FFFD\n // Check the value in case the final backslash was itself escaped.\n // Serialize as escaped U+FFFD, which is also interpreted as U+FFFD.\n // (Unescaped U+FFFD would also work, but removing the backslash is annoying.)\n missing_closing_characters.push_str(\"�\")\n }\n if is_unquoted_url && !input.slice_from(token_start).ends_with(\")\") {\n missing_closing_characters.push_str(\")\");\n }\n },\n _ => {},\n };\n }\n Ok((first_token_type, last_token_type))\n}\n\n/// Parse = type( ) | raw-string | number | .\n/// https://drafts.csswg.org/css-values-5/#attr-notation\nfn parse_attr_type<'i, 't>(input: &mut Parser<'i, 't>) -> AttributeType {\n input\n .try_parse(|input| {\n Ok(match input.next()? {\n Token::Function(ref name) if name.eq_ignore_ascii_case(\"type\") => {\n AttributeType::Type(\n input.parse_nested_block(SyntaxDescriptor::from_css_parser)?,\n )\n },\n Token::Ident(ref ident) => {\n if ident.eq_ignore_ascii_case(\"raw-string\") {\n AttributeType::RawString\n } else {\n let unit = AttrUnit::from_ident(ident).map_err(|_| {\n input.new_custom_error(StyleParseErrorKind::UnspecifiedError)\n })?;\n AttributeType::Unit(unit)\n }\n },\n Token::Delim('%') => AttributeType::Unit(AttrUnit::Percentage),\n _ => return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError)),\n })\n })\n .unwrap_or(AttributeType::None)\n}\n\n/// Attribute values may reference other substitution functions we may need to process.\n/// See step 6: https://drafts.csswg.org/css-values-5/#attr-substitution\nfn parse_attribute_value(\n name: &Atom,\n attribute_data: &AttributeData,\n url_data: &UrlExtraData,\n attribute_tracker: &mut AttributeTracker,\n) -> Result {\n #[cfg(feature = \"gecko\")]\n let local_name = LocalName::cast(name);\n #[cfg(feature = \"servo\")]\n let local_name = &LocalName::from(name.as_ref());\n let namespace = match attribute_data.namespace {\n ParsedNamespace::Known(ref ns) => ns,\n ParsedNamespace::Unknown => return Err(()),\n };\n let attr = attribute_tracker.query(local_name, namespace).ok_or(())?;\n let mut input = ParserInput::new(&attr);\n let mut parser = Parser::new(&mut input);\n // TODO(Bug 2021110): Support namespaced attributes in chained references.\n let value = VariableValue::parse(&mut parser, None, &url_data).map_err(|_| ())?;\n Ok(ComputedRegisteredValue::universal(Arc::new(value)))\n}\n\n#[derive(Default)]\nstruct SeenSubstitutionFunctions<'a> {\n var: PrecomputedHashSet<&'a Name>,\n attr: PrecomputedHashSet<&'a Name>,\n}\n\n/// A struct that takes care of encapsulating the cascade process for custom properties.\npub struct CustomPropertiesBuilder<'a, 'b: 'a> {\n seen: SeenSubstitutionFunctions<'a>,\n may_have_cycles: bool,\n has_color_scheme: bool,\n substitution_functions: ComputedSubstitutionFunctions,\n reverted: PrecomputedHashMap<&'a Name, (CascadePriority, RevertKind)>,\n stylist: &'a Stylist,\n computed_context: &'a mut computed::Context<'b>,\n references_from_non_custom_properties: NonCustomReferenceMap>,\n}\n\nfn find_non_custom_references(\n registration: &PropertyDescriptors,\n value: &VariableValue,\n may_have_color_scheme: bool,\n is_root_element: bool,\n include_universal: bool,\n) -> Option {\n let syntax = registration.syntax.as_ref()?;\n let dependent_types = syntax.dependent_types();\n let may_reference_length = dependent_types.intersects(DependentDataTypes::LENGTH)\n || (include_universal && syntax.is_universal());\n if may_reference_length {\n let value_dependencies = value.references.non_custom_references(is_root_element);\n if !value_dependencies.is_empty() {\n return Some(value_dependencies);\n }\n }\n if dependent_types.intersects(DependentDataTypes::COLOR) && may_have_color_scheme {\n // NOTE(emilio): We might want to add a NonCustomReferences::COLOR_SCHEME or something but\n // it's not really needed for correctness, so for now we use an Option for that to signal\n // that there might be a dependencies.\n return Some(NonCustomReferences::empty());\n }\n None\n}\n\nimpl<'a, 'b: 'a> CustomPropertiesBuilder<'a, 'b> {\n /// Create a new builder, inheriting from a given custom properties map.\n ///\n /// We expose this publicly mostly for @keyframe blocks.\n pub fn new_with_properties(\n stylist: &'a Stylist,\n custom_properties: ComputedCustomProperties,\n computed_context: &'a mut computed::Context<'b>,\n ) -> Self {\n Self {\n seen: SeenSubstitutionFunctions::default(),\n reverted: Default::default(),\n may_have_cycles: false,\n has_color_scheme: false,\n substitution_functions: ComputedSubstitutionFunctions::new(\n Some(custom_properties),\n None,\n ),\n stylist,\n computed_context,\n references_from_non_custom_properties: NonCustomReferenceMap::default(),\n }\n }\n\n /// Create a new builder, inheriting from the right style given context.\n pub fn new(stylist: &'a Stylist, context: &'a mut computed::Context<'b>) -> Self {\n let is_root_element = context.is_root_element();\n\n let inherited = context.inherited_custom_properties();\n let initial_values = stylist.get_custom_property_initial_values();\n let properties = ComputedCustomProperties {\n inherited: if is_root_element {\n debug_assert!(inherited.is_empty());\n initial_values.inherited.clone()\n } else {\n inherited.inherited.clone()\n },\n non_inherited: initial_values.non_inherited.clone(),\n };\n\n // Reuse flags from computing registered custom properties initial values, such as\n // whether they depend on viewport units.\n context\n .style()\n .add_flags(stylist.get_custom_property_initial_values_flags());\n Self::new_with_properties(stylist, properties, context)\n }\n\n /// Cascade a given custom property declaration.\n pub fn cascade(\n &mut self,\n declaration: &'a CustomDeclaration,\n priority: CascadePriority,\n attribute_tracker: &mut AttributeTracker,\n ) {\n let CustomDeclaration {\n ref name,\n ref value,\n } = *declaration;\n\n if let Some(&(reverted_priority, revert_kind)) = self.reverted.get(&name) {\n if !reverted_priority.allows_when_reverted(&priority, revert_kind) {\n return;\n }\n }\n\n if !(priority.flags() - self.computed_context.included_cascade_flags).is_empty() {\n return;\n }\n\n let was_already_present = !self.seen.var.insert(name);\n if was_already_present {\n return;\n }\n\n if !self.value_may_affect_style(name, value) {\n return;\n }\n\n let kind = SubstitutionFunctionKind::Var;\n let map = &mut self.substitution_functions;\n let registration = self.stylist.get_custom_property_registration(&name);\n match value {\n CustomDeclarationValue::Unparsed(unparsed_value) => {\n // At this point of the cascade we're not guaranteed to have seen the color-scheme\n // declaration, so need to assume the worst. We could track all system color\n // keyword tokens + the light-dark() function, but that seems non-trivial /\n // probably overkill.\n let may_have_color_scheme = true;\n // Non-custom dependency is really relevant for registered custom properties\n // that require computed value of such dependencies.\n let has_dependency = unparsed_value.references.any_var\n || unparsed_value.references.any_attr\n || find_non_custom_references(\n registration,\n unparsed_value,\n may_have_color_scheme,\n self.computed_context.is_root_element(),\n /* include_unregistered = */ false,\n )\n .is_some();\n // If the variable value has no references to other properties, perform\n // substitution here instead of forcing a full traversal in `substitute_all`\n // afterwards.\n if !has_dependency {\n return substitute_references_if_needed_and_apply(\n name,\n kind,\n unparsed_value,\n &mut self.substitution_functions,\n self.stylist,\n self.computed_context,\n attribute_tracker,\n );\n }\n self.may_have_cycles = true;\n let value = ComputedRegisteredValue::universal(Arc::clone(unparsed_value));\n map.insert_var(registration, name, value);\n },\n CustomDeclarationValue::Parsed(parsed_value) => {\n let value = parsed_value.to_computed_value(&self.computed_context);\n map.insert_var(registration, name, value);\n },\n CustomDeclarationValue::CSSWideKeyword(keyword) => match keyword.revert_kind() {\n Some(revert_kind) => {\n self.seen.var.remove(name);\n self.reverted.insert(name, (priority, revert_kind));\n },\n None => match keyword {\n CSSWideKeyword::Initial => {\n // For non-inherited custom properties, 'initial' was handled in value_may_affect_style.\n debug_assert!(registration.inherits(), \"Should've been handled earlier\");\n remove_and_insert_initial_value(name, registration, map);\n },\n CSSWideKeyword::Inherit => {\n // For inherited custom properties, 'inherit' was handled in value_may_affect_style.\n debug_assert!(!registration.inherits(), \"Should've been handled earlier\");\n self.computed_context\n .style()\n .add_flags(ComputedValueFlags::INHERITS_RESET_STYLE);\n if let Some(inherited_value) = self\n .computed_context\n .inherited_custom_properties()\n .non_inherited\n .get(name)\n {\n map.insert_var(registration, name, inherited_value.clone());\n }\n },\n // handled in value_may_affect_style or in the revert_kind branch above.\n CSSWideKeyword::Revert\n | CSSWideKeyword::RevertLayer\n | CSSWideKeyword::RevertRule\n | CSSWideKeyword::Unset => unreachable!(),\n },\n },\n }\n }\n\n /// Fast check to avoid calling maybe_note_non_custom_dependency in ~all cases.\n #[inline]\n pub fn might_have_non_custom_or_attr_dependency(\n id: LonghandId,\n decl: &PropertyDeclaration,\n ) -> bool {\n if id == LonghandId::ColorScheme {\n return true;\n }\n if let PropertyDeclaration::WithVariables(v) = decl {\n return matches!(id, LonghandId::LineHeight | LonghandId::FontSize)\n || v.value.variable_value.references.any_attr;\n }\n false\n }\n\n /// Note a non-custom property with variable reference that may in turn depend on that property.\n /// e.g. `font-size` depending on a custom property that may be a registered property using `em`.\n pub fn maybe_note_non_custom_dependency(\n &mut self,\n id: LonghandId,\n decl: &'a PropertyDeclaration,\n attribute_tracker: &mut AttributeTracker,\n ) {\n debug_assert!(Self::might_have_non_custom_or_attr_dependency(id, decl));\n if id == LonghandId::ColorScheme {\n // If we might change the color-scheme, we need to defer computation of colors.\n self.has_color_scheme = true;\n return;\n }\n\n let PropertyDeclaration::WithVariables(v) = decl else {\n return;\n };\n let value = &v.value.variable_value;\n let refs = &value.references;\n\n if !refs.any_var && !refs.any_attr {\n return;\n }\n\n // Attributes in non-custom properties may reference `var()` or `attr()` in their\n // values, which we need to track to support chained references and detect cycles.\n // Further processing occurs during `CustomPropertiesBuilder::build()`.\n if refs.any_attr {\n self.update_attributes_map(value, attribute_tracker);\n if !refs.any_var {\n return;\n }\n }\n\n // With unit algebra in `calc()`, references aren't limited to `font-size`.\n // For example, `--foo: 100ex; font-weight: calc(var(--foo) / 1ex);`,\n // or `--foo: 1em; zoom: calc(var(--foo) * 30px / 2em);`\n let references = match id {\n LonghandId::FontSize => {\n if self.computed_context.is_root_element() {\n NonCustomReferences::ROOT_FONT_UNITS\n } else {\n NonCustomReferences::FONT_UNITS\n }\n },\n LonghandId::LineHeight => {\n if self.computed_context.is_root_element() {\n NonCustomReferences::ROOT_LH_UNITS | NonCustomReferences::ROOT_FONT_UNITS\n } else {\n NonCustomReferences::LH_UNITS | NonCustomReferences::FONT_UNITS\n }\n },\n _ => return,\n };\n\n let variables: Vec = refs\n .refs\n .iter()\n .filter_map(|reference| {\n if reference.substitution_kind != SubstitutionFunctionKind::Var {\n return None;\n }\n let registration = self\n .stylist\n .get_custom_property_registration(&reference.name);\n if !registration\n .syntax\n .as_ref()?\n .dependent_types()\n .intersects(DependentDataTypes::LENGTH)\n {\n return None;\n }\n Some(reference.name.clone())\n })\n .collect();\n references.for_each(|idx| {\n let entry = &mut self.references_from_non_custom_properties[idx];\n let was_none = entry.is_none();\n let v = entry.get_or_insert_with(|| variables.clone());\n if was_none {\n return;\n }\n v.extend(variables.iter().cloned());\n });\n }\n\n fn value_may_affect_style(&self, name: &Name, value: &CustomDeclarationValue) -> bool {\n let registration = self.stylist.get_custom_property_registration(&name);\n match *value {\n CustomDeclarationValue::CSSWideKeyword(CSSWideKeyword::Inherit) => {\n // For inherited custom properties, explicit 'inherit' means we\n // can just use any existing value in the inherited\n // CustomPropertiesMap.\n if registration.inherits() {\n return false;\n }\n },\n CustomDeclarationValue::CSSWideKeyword(CSSWideKeyword::Initial) => {\n // For non-inherited custom properties, explicit 'initial' means\n // we can just use any initial value in the registration.\n if !registration.inherits() {\n return false;\n }\n },\n CustomDeclarationValue::CSSWideKeyword(CSSWideKeyword::Unset) => {\n // Explicit 'unset' means we can either just use any existing\n // value in the inherited CustomPropertiesMap or the initial\n // value in the registration.\n return false;\n },\n _ => {},\n }\n\n let existing_value = self.substitution_functions.get_var(registration, &name);\n let existing_value = match existing_value {\n None => {\n if matches!(\n value,\n CustomDeclarationValue::CSSWideKeyword(CSSWideKeyword::Initial)\n ) {\n debug_assert!(registration.inherits(), \"Should've been handled earlier\");\n // The initial value of a custom property without a\n // guaranteed-invalid initial value is the same as it\n // not existing in the map.\n if registration.initial_value.is_none() {\n return false;\n }\n }\n return true;\n },\n Some(v) => v,\n };\n let computed_value = match value {\n CustomDeclarationValue::Unparsed(value) => {\n // Don't bother overwriting an existing value with the same\n // specified value.\n if let Some(existing_value) = existing_value.as_universal() {\n return existing_value != value;\n }\n if !registration.is_universal() {\n compute_value(\n &value.css,\n &value.url_data,\n registration,\n self.computed_context,\n AttrTaint::default(),\n )\n .ok()\n } else {\n None\n }\n },\n CustomDeclarationValue::Parsed(value) => {\n Some(value.to_computed_value(&self.computed_context))\n },\n CustomDeclarationValue::CSSWideKeyword(kw) => {\n match kw {\n CSSWideKeyword::Inherit => {\n debug_assert!(!registration.inherits(), \"Should've been handled earlier\");\n // existing_value is the registered initial value.\n // Don't bother adding it to self.custom_properties.non_inherited\n // if the key is also absent from self.inherited.non_inherited.\n if self\n .computed_context\n .inherited_custom_properties()\n .non_inherited\n .get(name)\n .is_none()\n {\n return false;\n }\n },\n CSSWideKeyword::Initial => {\n debug_assert!(registration.inherits(), \"Should've been handled earlier\");\n // Don't bother overwriting an existing value with the initial value specified in\n // the registration.\n if let Some(initial_value) = self\n .stylist\n .get_custom_property_initial_values()\n .get(registration, name)\n {\n return existing_value != initial_value;\n }\n },\n CSSWideKeyword::Unset => {\n debug_assert!(false, \"Should've been handled earlier\");\n },\n CSSWideKeyword::Revert\n | CSSWideKeyword::RevertLayer\n | CSSWideKeyword::RevertRule => {},\n }\n None\n },\n };\n\n if let Some(value) = computed_value {\n return existing_value.v != value.v;\n }\n\n true\n }\n\n /// For a given unparsed variable, update the attributes map with its attr references.\n pub fn update_attributes_map(\n &mut self,\n value: &'a VariableValue,\n attribute_tracker: &mut AttributeTracker,\n ) {\n let refs = &value.references;\n if !refs.any_attr {\n return;\n }\n self.may_have_cycles = true;\n\n for next in &refs.refs {\n // Skip non-attrs and attributes we've already processed.\n if next.substitution_kind != SubstitutionFunctionKind::Attr\n || !self.seen.attr.insert(&next.name)\n {\n continue;\n }\n if let Ok(v) = parse_attribute_value(\n &next.name,\n &next.attribute_data,\n &value.url_data,\n attribute_tracker,\n ) {\n self.substitution_functions.insert_attr(&next.name, v);\n }\n }\n }\n\n /// Computes the map of applicable custom properties, as well as\n /// longhand properties that are now considered invalid-at-compute time.\n /// The result is saved into the computed context.\n ///\n /// If there was any specified property or non-inherited custom property\n /// with an initial value, we've created a new map and now we\n /// need to remove any potential cycles (And marking non-custom\n /// properties), and wrap it in an arc.\n ///\n /// Some registered custom properties may require font-related properties\n /// be resolved to resolve. If these properties are not resolved at this time,\n /// `defer` should be set to `Yes`, which will leave such custom properties,\n /// and other properties referencing them, untouched. These properties are\n /// returned separately, to be resolved by `build_deferred` to fully resolve\n /// all custom properties after all necessary non-custom properties are resolved.\n pub fn build(\n mut self,\n defer: DeferFontRelativeCustomPropertyResolution,\n attribute_tracker: &mut AttributeTracker,\n ) -> Option {\n let mut deferred_substitution_functions = None;\n if self.may_have_cycles {\n if defer == DeferFontRelativeCustomPropertyResolution::Yes {\n deferred_substitution_functions = Some(AllSubstitutionFunctions::default());\n }\n let mut invalid_non_custom_properties = LonghandIdSet::default();\n substitute_all(\n &mut self.substitution_functions,\n deferred_substitution_functions.as_mut(),\n &mut invalid_non_custom_properties,\n self.has_color_scheme,\n &self.seen,\n &self.references_from_non_custom_properties,\n self.stylist,\n self.computed_context,\n attribute_tracker,\n );\n self.computed_context.builder.invalid_non_custom_properties =\n invalid_non_custom_properties;\n }\n self.substitution_functions\n .custom_properties\n .shrink_to_fit();\n\n // Some pages apply a lot of redundant custom properties, see e.g.\n // bug 1758974 comment 5. Try to detect the case where the values\n // haven't really changed, and save some memory by reusing the inherited\n // map in that case.\n let initial_values = self.stylist.get_custom_property_initial_values();\n let custom_properties = self.substitution_functions.custom_properties;\n self.computed_context\n .builder\n .substitution_functions\n .custom_properties = ComputedCustomProperties {\n inherited: if self\n .computed_context\n .inherited_custom_properties()\n .inherited\n == custom_properties.inherited\n {\n self.computed_context\n .inherited_custom_properties()\n .inherited\n .clone()\n } else {\n custom_properties.inherited\n },\n non_inherited: if initial_values.non_inherited == custom_properties.non_inherited {\n initial_values.non_inherited.clone()\n } else {\n custom_properties.non_inherited\n },\n };\n self.computed_context\n .builder\n .substitution_functions\n .attributes = self.substitution_functions.attributes;\n\n deferred_substitution_functions\n }\n\n /// Fully resolve all deferred custom properties and attributes, assuming that the\n /// incoming context has necessary properties resolved.\n pub fn build_deferred(\n deferred: AllSubstitutionFunctions,\n stylist: &Stylist,\n computed_context: &mut computed::Context,\n attribute_tracker: &mut AttributeTracker,\n ) {\n if deferred.is_empty() {\n return;\n }\n let mut map = std::mem::take(&mut computed_context.builder.substitution_functions);\n // Since `CustomPropertiesMap` preserves insertion order, we shouldn't have to worry about\n // resolving in a wrong order.\n for (name, kind, v) in deferred.iter() {\n let Some(v) = v.as_universal() else {\n unreachable!(\"Computing should have been deferred!\")\n };\n substitute_references_if_needed_and_apply(\n name,\n kind,\n v,\n &mut map,\n stylist,\n computed_context,\n attribute_tracker,\n );\n }\n computed_context.builder.substitution_functions = map;\n }\n}\n\n/// Resolve all custom properties to either substituted, invalid, or unset\n/// (meaning we should use the inherited value).\n///\n/// It does cycle dependencies removal at the same time as substitution.\nfn substitute_all(\n substitution_function_map: &mut ComputedSubstitutionFunctions,\n mut deferred_substituted_functions_map: Option<&mut AllSubstitutionFunctions>,\n invalid_non_custom_properties: &mut LonghandIdSet,\n has_color_scheme: bool,\n seen: &SeenSubstitutionFunctions,\n references_from_non_custom_properties: &NonCustomReferenceMap>,\n stylist: &Stylist,\n computed_context: &computed::Context,\n attr_tracker: &mut AttributeTracker,\n) {\n // The cycle dependencies removal in this function is a variant\n // of Tarjan's algorithm. It is mostly based on the pseudo-code\n // listed in\n // https://en.wikipedia.org/w/index.php?\n // title=Tarjan%27s_strongly_connected_components_algorithm&oldid=801728495\n\n #[derive(Clone, Eq, PartialEq, Debug)]\n enum VarType {\n Attr(Name),\n Custom(Name),\n NonCustom(SingleNonCustomReference),\n }\n\n /// Struct recording necessary information for each variable.\n #[derive(Debug)]\n struct VarInfo {\n /// The name of the variable. It will be taken to save addref\n /// when the corresponding variable is popped from the stack.\n /// This also serves as a mark for whether the variable is\n /// currently in the stack below.\n var: Option,\n /// If the variable is in a dependency cycle, lowlink represents\n /// a smaller index which corresponds to a variable in the same\n /// strong connected component, which is known to be accessible\n /// from this variable. It is not necessarily the root, though.\n lowlink: usize,\n }\n /// Context struct for traversing the variable graph, so that we can\n /// avoid referencing all the fields multiple times.\n struct Context<'a, 'b: 'a> {\n /// Number of variables visited. This is used as the order index\n /// when we visit a new unresolved variable.\n count: usize,\n /// The map from custom property name to its order index.\n index_map: PrecomputedHashMap,\n /// Mapping from a non-custom dependency to its order index.\n non_custom_index_map: NonCustomReferenceMap,\n /// Information of each variable indexed by the order index.\n var_info: SmallVec<[VarInfo; 5]>,\n /// The stack of order index of visited variables. It contains\n /// all unfinished strong connected components.\n stack: SmallVec<[usize; 5]>,\n /// References to non-custom properties in this strongly connected component.\n non_custom_references: NonCustomReferences,\n /// Whether the builder has seen a non-custom color-scheme reference.\n has_color_scheme: bool,\n /// Whether this strongly connected component contains any custom properties involving\n /// value computation.\n contains_computed_custom_property: bool,\n map: &'a mut ComputedSubstitutionFunctions,\n /// The stylist is used to get registered properties, and to resolve the environment to\n /// substitute `env()` variables.\n stylist: &'a Stylist,\n /// The computed context is used to get inherited custom\n /// properties and compute registered custom properties.\n computed_context: &'a computed::Context<'b>,\n /// Longhand IDs that became invalid due to dependency cycle(s).\n invalid_non_custom_properties: &'a mut LonghandIdSet,\n /// Substitution functions that cannot yet be substituted. We store both custom\n /// properties (inherited and non-inherited) and attributes in the same map, since\n /// we need to make sure we iterate through them in the right order.\n deferred_substitution_functions: Option<&'a mut AllSubstitutionFunctions>,\n }\n\n /// This function combines the traversal for cycle removal and value\n /// substitution. It returns either a signal None if this variable\n /// has been fully resolved (to either having no reference or being\n /// marked invalid), or the order index for the given name.\n ///\n /// When it returns, the variable corresponds to the name would be\n /// in one of the following states:\n /// * It is still in context.stack, which means it is part of an\n /// potentially incomplete dependency circle.\n /// * It has been removed from the map. It can be either that the\n /// substitution failed, or it is inside a dependency circle.\n /// When this function removes a variable from the map because\n /// of dependency circle, it would put all variables in the same\n /// strong connected component to the set together.\n /// * It doesn't have any reference, because either this variable\n /// doesn't have reference at all in specified value, or it has\n /// been completely resolved.\n /// * There is no such variable at all.\n fn traverse<'a, 'b>(\n var: VarType,\n non_custom_references: &NonCustomReferenceMap>,\n context: &mut Context<'a, 'b>,\n attribute_tracker: &mut AttributeTracker,\n ) -> Option {\n let kind = if matches!(var, VarType::Custom(_)) {\n SubstitutionFunctionKind::Var\n } else {\n SubstitutionFunctionKind::Attr\n };\n // Some shortcut checks.\n let value = match var {\n VarType::Custom(ref name) | VarType::Attr(ref name) => {\n let registration;\n let value;\n match kind {\n SubstitutionFunctionKind::Var => {\n registration = context.stylist.get_custom_property_registration(name);\n value = context.map.get_var(registration, name)?.as_universal()?;\n },\n SubstitutionFunctionKind::Attr => {\n // FIXME(bug1997338): registration does not make much sense for attrs.\n // Rework find_non_custom_references to take Descriptor instead?\n registration = PropertyDescriptors::unregistered();\n value = context.map.get_attr(name)?.as_universal()?;\n },\n _ => unreachable!(\"Substitution kind must be var or attr for VarType::Custom.\"),\n }\n let is_var = kind == SubstitutionFunctionKind::Var;\n let is_attr = kind == SubstitutionFunctionKind::Attr;\n let is_root = context.computed_context.is_root_element();\n // We need to keep track of potential non-custom-references even on unregistered\n // properties for cycle-detection purposes.\n let non_custom_refs = find_non_custom_references(\n registration,\n value,\n context.has_color_scheme,\n is_root,\n /* include_unregistered = */ true,\n );\n context.non_custom_references |= non_custom_refs.unwrap_or_default();\n let has_dependency = value.references.any_var\n || value.references.any_attr\n || non_custom_refs.is_some();\n // Nothing to resolve.\n if !has_dependency {\n debug_assert!(!value.references.any_env, \"Should've been handled earlier\");\n if is_attr || !registration.is_universal() {\n // We might still need to compute the value if this is not an universal\n // registration if we thought this had a dependency before but turned out\n // not to be (due to has_color_scheme, for example). Note that if this was\n // already computed we would've bailed out in the as_universal() check.\n if is_var {\n debug_assert!(\n registration\n .syntax\n .as_ref()\n .unwrap()\n .dependent_types()\n .intersects(DependentDataTypes::COLOR),\n \"How did an unresolved value get here otherwise?\",\n );\n }\n let value = value.clone();\n substitute_references_if_needed_and_apply(\n name,\n kind,\n &value,\n &mut context.map,\n context.stylist,\n context.computed_context,\n attribute_tracker,\n );\n }\n return None;\n }\n\n // Has this variable been visited?\n // FIXME(bug1997338): a name conflict between between y and --y is possible\n // because they refer to the same atom. E.g. `attr(y type(*))` where\n // `y=\"var(--y)\"` and `--y: var(--baz)`.\n match context.index_map.entry(name.clone()) {\n Entry::Occupied(entry) => {\n return Some(*entry.get());\n },\n Entry::Vacant(entry) => {\n entry.insert(context.count);\n },\n }\n context.contains_computed_custom_property |= is_var && !registration.is_universal();\n\n // Hold a strong reference to the value so that we don't\n // need to keep reference to context.map.\n Some(value.clone())\n },\n VarType::NonCustom(ref non_custom) => {\n let entry = &mut context.non_custom_index_map[*non_custom];\n if let Some(v) = entry {\n return Some(*v);\n }\n *entry = Some(context.count);\n None\n },\n };\n\n // Add new entry to the information table.\n let index = context.count;\n context.count += 1;\n debug_assert_eq!(index, context.var_info.len());\n context.var_info.push(VarInfo {\n var: Some(var.clone()),\n lowlink: index,\n });\n context.stack.push(index);\n\n let mut self_ref = false;\n let mut lowlink = index;\n let visit_link = |var: VarType,\n context: &mut Context,\n lowlink: &mut usize,\n self_ref: &mut bool,\n attr_tracker: &mut AttributeTracker| {\n let next_index = match traverse(var, non_custom_references, context, attr_tracker) {\n Some(index) => index,\n // There is nothing to do if the next variable has been\n // fully resolved at this point.\n None => {\n return;\n },\n };\n let next_info = &context.var_info[next_index];\n if next_index > index {\n // The next variable has a larger index than us, so it\n // must be inserted in the recursive call above. We want\n // to get its lowlink.\n *lowlink = cmp::min(*lowlink, next_info.lowlink);\n } else if next_index == index {\n *self_ref = true;\n } else if next_info.var.is_some() {\n // The next variable has a smaller order index and it is\n // in the stack, so we are at the same component.\n *lowlink = cmp::min(*lowlink, next_index);\n }\n };\n if let Some(ref v) = value.as_ref() {\n debug_assert!(\n matches!(var, VarType::Custom(_) | VarType::Attr(_)),\n \"Non-custom property has references?\"\n );\n\n // Visit other custom properties...\n // FIXME: Maybe avoid visiting the same var twice if not needed?\n for next in &v.references.refs {\n if next.substitution_kind == SubstitutionFunctionKind::Env {\n continue;\n }\n\n let next_var = if next.substitution_kind == SubstitutionFunctionKind::Attr {\n if context.map.get_attr(&next.name).is_none() {\n let Ok(val) = parse_attribute_value(\n &next.name,\n &next.attribute_data,\n &v.url_data,\n attribute_tracker,\n ) else {\n continue;\n };\n context.map.insert_attr(&next.name, val);\n }\n VarType::Attr(next.name.clone())\n } else {\n VarType::Custom(next.name.clone())\n };\n\n visit_link(\n next_var,\n context,\n &mut lowlink,\n &mut self_ref,\n attribute_tracker,\n );\n }\n\n // ... Then non-custom properties.\n v.references.non_custom_references.for_each(|r| {\n visit_link(\n VarType::NonCustom(r),\n context,\n &mut lowlink,\n &mut self_ref,\n attribute_tracker,\n );\n });\n } else if let VarType::NonCustom(non_custom) = var {\n let entry = &non_custom_references[non_custom];\n if let Some(deps) = entry.as_ref() {\n for d in deps {\n // Visit any reference from this non-custom property to custom properties.\n // TODO(bug1997338): non-custom properties can reference attrs.\n visit_link(\n VarType::Custom(d.clone()),\n context,\n &mut lowlink,\n &mut self_ref,\n attribute_tracker,\n );\n }\n }\n }\n\n context.var_info[index].lowlink = lowlink;\n if lowlink != index {\n // This variable is in a loop, but it is not the root of\n // this strong connected component. We simply return for\n // now, and the root would remove it from the map.\n //\n // This cannot be removed from the map here, because\n // otherwise the shortcut check at the beginning of this\n // function would return the wrong value.\n return Some(index);\n }\n\n // This is the root of a strong-connected component.\n let mut in_loop = self_ref;\n let name;\n\n let handle_variable_in_loop =\n |name: &Name, context: &mut Context<'a, 'b>, kind: SubstitutionFunctionKind| {\n if context.contains_computed_custom_property {\n // These non-custom properties can't become invalid-at-compute-time from\n // cyclic dependencies purely consisting of non-registered properties.\n if context.non_custom_references.intersects(\n NonCustomReferences::FONT_UNITS | NonCustomReferences::ROOT_FONT_UNITS,\n ) {\n context\n .invalid_non_custom_properties\n .insert(LonghandId::FontSize);\n }\n if context.non_custom_references.intersects(\n NonCustomReferences::LH_UNITS | NonCustomReferences::ROOT_LH_UNITS,\n ) {\n context\n .invalid_non_custom_properties\n .insert(LonghandId::LineHeight);\n }\n }\n // This variable is in loop. Resolve to invalid.\n handle_invalid_at_computed_value_time(\n name,\n kind,\n &mut context.map,\n context.computed_context,\n );\n };\n loop {\n let var_index = context\n .stack\n .pop()\n .expect(\"The current variable should still be in stack\");\n let var_info = &mut context.var_info[var_index];\n // We should never visit the variable again, so it's safe\n // to take the name away, so that we don't do additional\n // reference count.\n let var_name = var_info\n .var\n .take()\n .expect(\"Variable should not be poped from stack twice\");\n if var_index == index {\n name = match var_name {\n VarType::Custom(name) | VarType::Attr(name) => name,\n // At the root of this component, and it's a non-custom\n // reference - we have nothing to substitute, so\n // it's effectively resolved.\n VarType::NonCustom(..) => return None,\n };\n break;\n }\n if let VarType::Custom(name) | VarType::Attr(name) = var_name {\n // Anything here is in a loop which can traverse to the\n // variable we are handling, so it's invalid at\n // computed-value time.\n handle_variable_in_loop(&name, context, kind);\n }\n in_loop = true;\n }\n // We've gotten to the root of this strongly connected component, so clear\n // whether or not it involved non-custom references.\n // It's fine to track it like this, because non-custom properties currently\n // being tracked can only participate in any loop only once.\n if in_loop {\n handle_variable_in_loop(&name, context, kind);\n context.non_custom_references = NonCustomReferences::default();\n return None;\n }\n\n if let Some(ref v) = value {\n let registration = context.stylist.get_custom_property_registration(&name);\n\n let mut defer = false;\n if let Some(ref mut deferred) = context.deferred_substitution_functions {\n // We need to defer this property if it has a non-custom property dependency, or\n // any variable that it references is already deferred.\n defer = find_non_custom_references(\n registration,\n v,\n context.has_color_scheme,\n context.computed_context.is_root_element(),\n /* include_unregistered = */ false,\n )\n .is_some()\n || v.references.refs.iter().any(|reference| {\n (reference.substitution_kind == SubstitutionFunctionKind::Var\n && deferred\n .get(&reference.name, SubstitutionFunctionKind::Var)\n .is_some())\n || reference.substitution_kind == SubstitutionFunctionKind::Attr\n });\n if defer {\n let value = ComputedRegisteredValue::universal(Arc::clone(v));\n deferred.insert(&name, kind, value);\n if kind == SubstitutionFunctionKind::Var {\n context.map.remove_var(registration, &name);\n } else {\n context.map.remove_attr(&name);\n }\n }\n }\n\n // If there are no var or attr references we should already be computed and substituted by now.\n if !defer && (v.references.any_var || v.references.any_attr) {\n substitute_references_if_needed_and_apply(\n &name,\n kind,\n v,\n &mut context.map,\n context.stylist,\n context.computed_context,\n attribute_tracker,\n );\n }\n }\n context.non_custom_references = NonCustomReferences::default();\n\n // All resolved, so return the signal value.\n None\n }\n\n let mut run = |make_var: fn(Name) -> VarType, seen: &PrecomputedHashSet<&Name>| {\n for name in seen {\n let mut context = Context {\n count: 0,\n index_map: PrecomputedHashMap::default(),\n non_custom_index_map: NonCustomReferenceMap::default(),\n stack: SmallVec::new(),\n var_info: SmallVec::new(),\n map: substitution_function_map,\n non_custom_references: NonCustomReferences::default(),\n has_color_scheme,\n stylist,\n computed_context,\n invalid_non_custom_properties,\n deferred_substitution_functions: deferred_substituted_functions_map.as_deref_mut(),\n contains_computed_custom_property: false,\n };\n\n traverse(\n make_var((*name).clone()),\n references_from_non_custom_properties,\n &mut context,\n attr_tracker,\n );\n }\n };\n\n // Note that `seen` doesn't contain names inherited from our parent, but\n // those can't have variable references (since we inherit the computed\n // variables) so we don't want to spend cycles traversing them anyway.\n run(VarType::Custom, &seen.var);\n // Traverse potentially untraversed chained references from `attr(type())`\n // in non-custom properties.\n run(VarType::Attr, &seen.attr);\n}\n\n// See https://drafts.csswg.org/css-variables-2/#invalid-at-computed-value-time\nfn handle_invalid_at_computed_value_time(\n name: &Name,\n kind: SubstitutionFunctionKind,\n substitution_functions: &mut ComputedSubstitutionFunctions,\n computed_context: &computed::Context,\n) {\n if kind == SubstitutionFunctionKind::Attr {\n // Early return: `attr()` is always treated as unregistered.\n substitution_functions.remove_attr(name);\n return;\n }\n\n let stylist = computed_context.style().stylist.unwrap();\n let registration = stylist.get_custom_property_registration(&name);\n if !registration.is_universal() {\n // For the root element, inherited maps are empty. We should just\n // use the initial value if any, rather than removing the name.\n if registration.inherits() && !computed_context.is_root_element() {\n let inherited = computed_context.inherited_custom_properties();\n if let Some(value) = inherited.get(registration, name) {\n substitution_functions.insert_var(registration, name, value.clone());\n return;\n }\n } else if let Some(ref initial_value) = registration.initial_value {\n if let Ok(initial_value) = compute_value(\n &initial_value.css,\n &initial_value.url_data,\n registration,\n computed_context,\n AttrTaint::default(),\n ) {\n substitution_functions.insert_var(registration, name, initial_value);\n return;\n }\n }\n }\n substitution_functions.remove_var(registration, name);\n}\n\n/// Replace `var()`, `env()`, and `attr()` functions in a pre-existing variable value.\nfn substitute_references_if_needed_and_apply(\n name: &Name,\n kind: SubstitutionFunctionKind,\n value: &Arc,\n substitution_functions: &mut ComputedSubstitutionFunctions,\n stylist: &Stylist,\n computed_context: &computed::Context,\n attribute_tracker: &mut AttributeTracker,\n) {\n debug_assert_ne!(kind, SubstitutionFunctionKind::Env);\n let is_var = kind == SubstitutionFunctionKind::Var;\n let registration = stylist.get_custom_property_registration(&name);\n if is_var && !value.has_references() && registration.is_universal() {\n // Trivial path: no references and no need to compute the value, just apply it directly.\n let computed_value = ComputedRegisteredValue::universal(Arc::clone(value));\n substitution_functions.insert_var(registration, name, computed_value);\n return;\n }\n\n let inherited = computed_context.inherited_custom_properties();\n let url_data = &value.url_data;\n let substitution = match substitute_internal(\n value,\n substitution_functions,\n stylist,\n computed_context,\n attribute_tracker,\n None,\n ) {\n Ok(v) => v,\n Err(..) => {\n handle_invalid_at_computed_value_time(\n name,\n kind,\n substitution_functions,\n computed_context,\n );\n return;\n },\n };\n\n // TODO(bug1997338): rework with attr.\n // If variable fallback results in a wide keyword, deal with it now.\n {\n let css = &substitution.css;\n let css_wide_kw = {\n let mut input = ParserInput::new(&css);\n let mut input = Parser::new(&mut input);\n input.try_parse(CSSWideKeyword::parse)\n };\n\n if let Ok(kw) = css_wide_kw {\n // TODO: It's unclear what this should do for revert / revert-layer, see\n // https://github.com/w3c/csswg-drafts/issues/9131. For now treating as unset\n // seems fine?\n match (\n kw,\n registration.inherits(),\n computed_context.is_root_element(),\n ) {\n (CSSWideKeyword::Initial, _, _)\n | (CSSWideKeyword::Revert, false, _)\n | (CSSWideKeyword::RevertLayer, false, _)\n | (CSSWideKeyword::RevertRule, false, _)\n | (CSSWideKeyword::Unset, false, _)\n | (CSSWideKeyword::Revert, true, true)\n | (CSSWideKeyword::RevertLayer, true, true)\n | (CSSWideKeyword::RevertRule, true, true)\n | (CSSWideKeyword::Unset, true, true)\n | (CSSWideKeyword::Inherit, _, true) => {\n remove_and_insert_initial_value(name, registration, substitution_functions);\n },\n (CSSWideKeyword::Revert, true, false)\n | (CSSWideKeyword::RevertLayer, true, false)\n | (CSSWideKeyword::RevertRule, true, false)\n | (CSSWideKeyword::Inherit, _, false)\n | (CSSWideKeyword::Unset, true, false) => {\n match inherited.get(registration, name) {\n Some(value) => {\n substitution_functions.insert_var(registration, name, value.clone());\n },\n None => {\n substitution_functions.remove_var(registration, name);\n },\n };\n },\n }\n return;\n }\n }\n\n match kind {\n SubstitutionFunctionKind::Var => {\n let value = match substitution.into_value(url_data, registration, computed_context) {\n Ok(v) => v,\n Err(()) => {\n handle_invalid_at_computed_value_time(\n name,\n kind,\n substitution_functions,\n computed_context,\n );\n return;\n },\n };\n substitution_functions.insert_var(registration, name, value);\n },\n SubstitutionFunctionKind::Attr => {\n let mut value = ComputedRegisteredValue::universal(Arc::new(VariableValue::new(\n substitution.css.into_owned(),\n url_data,\n substitution.first_token_type,\n substitution.last_token_type,\n )));\n value.attr_tainted |= substitution.attr_tainted;\n substitution_functions.insert_attr(name, value);\n },\n SubstitutionFunctionKind::Env => unreachable!(\"Kind cannot be env.\"),\n }\n}\n\n#[derive(Default, Debug)]\nstruct Substitution<'a> {\n css: Cow<'a, str>,\n first_token_type: TokenSerializationType,\n last_token_type: TokenSerializationType,\n attr_tainted: bool,\n}\n\nimpl<'a> Substitution<'a> {\n fn from_value(v: VariableValue, attr_tainted: bool) -> Self {\n Substitution {\n css: v.css.into(),\n first_token_type: v.first_token_type,\n last_token_type: v.last_token_type,\n attr_tainted,\n }\n }\n\n fn into_value(\n self,\n url_data: &UrlExtraData,\n registration: &PropertyDescriptors,\n computed_context: &computed::Context,\n ) -> Result {\n if registration.is_universal() {\n let mut value = ComputedRegisteredValue::universal(Arc::new(VariableValue::new(\n self.css.into_owned(),\n url_data,\n self.first_token_type,\n self.last_token_type,\n )));\n value.attr_tainted |= self.attr_tainted;\n return Ok(value);\n }\n let taint = if self.attr_tainted {\n // Per spec: substitution value of an arbitrary substitution function is\n // attr()-tainted as a whole if any attr()-tainted values were involved\n // in creating that substitution value.\n // https://drafts.csswg.org/css-values-5/#attr-security\n AttrTaint::new_fully_tainted(self.css.len())\n } else {\n AttrTaint::default()\n };\n let mut v = compute_value(&self.css, url_data, registration, computed_context, taint)?;\n v.attr_tainted |= self.attr_tainted;\n Ok(v)\n }\n\n fn new(\n css: Cow<'a, str>,\n first_token_type: TokenSerializationType,\n last_token_type: TokenSerializationType,\n attr_tainted: bool,\n ) -> Self {\n Self {\n css,\n first_token_type,\n last_token_type,\n attr_tainted,\n }\n }\n}\n\n/// Result of var(), env(), and attr() substitution.\n#[derive(Debug)]\npub struct SubstitutionResult<'a> {\n /// The resolved CSS string after substitution.\n pub css: Cow<'a, str>,\n /// Regions in the `css` string that are attr()-tainted, if any.\n pub attr_taint: AttrTaint,\n}\n\nfn compute_value(\n css: &str,\n url_data: &UrlExtraData,\n registration: &PropertyDescriptors,\n computed_context: &computed::Context,\n attr_taint: AttrTaint,\n) -> Result {\n debug_assert!(!registration.is_universal());\n\n let mut input = ParserInput::new(&css);\n let mut input = Parser::new(&mut input);\n\n SpecifiedRegisteredValue::compute(\n &mut input,\n registration,\n None,\n url_data,\n computed_context,\n AllowComputationallyDependent::Yes,\n attr_taint,\n )\n}\n\n/// Removes the named registered custom property and inserts its uncomputed initial value.\nfn remove_and_insert_initial_value(\n name: &Name,\n registration: &PropertyDescriptors,\n substitution_functions: &mut ComputedSubstitutionFunctions,\n) {\n substitution_functions.remove_var(registration, name);\n if let Some(ref initial_value) = registration.initial_value {\n let value = ComputedRegisteredValue::universal(Arc::clone(initial_value));\n substitution_functions.insert_var(registration, name, value);\n }\n}\n\nfn do_substitute_chunk<'a>(\n css: &'a str,\n start: usize,\n end: usize,\n first_token_type: TokenSerializationType,\n last_token_type: TokenSerializationType,\n url_data: &UrlExtraData,\n substitution_functions: &'a ComputedSubstitutionFunctions,\n stylist: &Stylist,\n computed_context: &computed::Context,\n references: &mut std::iter::Peekable>,\n attribute_tracker: &mut AttributeTracker,\n mut attr_taint: Option<&mut AttrTaint>,\n) -> Result, ()> {\n if start == end {\n // Empty string. Easy.\n return Ok(Substitution::default());\n }\n // Easy case: no references involved.\n if references\n .peek()\n .map_or(true, |reference| reference.end > end)\n {\n let result = &css[start..end];\n return Ok(Substitution::new(\n Cow::Borrowed(result),\n first_token_type,\n last_token_type,\n Default::default(),\n ));\n }\n\n let mut substituted = ComputedValue::empty(url_data);\n let mut next_token_type = first_token_type;\n let mut cur_pos = start;\n let mut attr_tainted = false;\n while let Some(reference) = references.next_if(|reference| reference.end <= end) {\n if reference.start != cur_pos {\n substituted.push(\n &css[cur_pos..reference.start],\n next_token_type,\n reference.prev_token_type,\n /* attr_taint */ None,\n )?;\n }\n\n let substitution = substitute_one_reference(\n css,\n url_data,\n substitution_functions,\n reference,\n stylist,\n computed_context,\n references,\n attribute_tracker,\n )?;\n\n // Optimize the property: var(--...) case to avoid allocating at all.\n if reference.start == start && reference.end == end {\n if let Some(taint) = attr_taint.filter(|_| substitution.attr_tainted) {\n taint.push(start, end);\n }\n return Ok(substitution);\n }\n\n substituted.push(\n &substitution.css,\n substitution.first_token_type,\n substitution.last_token_type,\n attr_taint\n .as_deref_mut()\n .filter(|_| substitution.attr_tainted),\n )?;\n attr_tainted |= substitution.attr_tainted;\n next_token_type = reference.next_token_type;\n cur_pos = reference.end;\n }\n // Push the rest of the value if needed.\n if cur_pos != end {\n substituted.push(\n &css[cur_pos..end],\n next_token_type,\n last_token_type,\n /* attr_taint */ None,\n )?;\n }\n Ok(Substitution::from_value(substituted, attr_tainted))\n}\n\nfn quoted_css_string(src: &str) -> String {\n let mut dest = String::with_capacity(src.len() + 2);\n cssparser::serialize_string(src, &mut dest).unwrap();\n dest\n}\n\nfn substitute_one_reference<'a>(\n css: &'a str,\n url_data: &UrlExtraData,\n substitution_functions: &'a ComputedSubstitutionFunctions,\n reference: &SubstitutionFunctionReference,\n stylist: &Stylist,\n computed_context: &computed::Context,\n references: &mut std::iter::Peekable>,\n attribute_tracker: &mut AttributeTracker,\n) -> Result, ()> {\n let simple_attr_subst = |s: &str| {\n Some(Substitution::new(\n Cow::Owned(quoted_css_string(s)),\n TokenSerializationType::Nothing,\n TokenSerializationType::Nothing,\n /* attr_tainted */ true,\n ))\n };\n let substitution: Option<_> = match reference.substitution_kind {\n SubstitutionFunctionKind::Var => {\n let registration = stylist.get_custom_property_registration(&reference.name);\n substitution_functions\n .get_var(registration, &reference.name)\n .map(|v| Substitution::from_value(v.to_variable_value(), v.attr_tainted))\n },\n SubstitutionFunctionKind::Env => {\n let device = stylist.device();\n device\n .environment()\n .get(&reference.name, device, url_data)\n .map(|v| Substitution::from_value(v, /* attr_tainted */ false))\n },\n // https://drafts.csswg.org/css-values-5/#attr-substitution\n SubstitutionFunctionKind::Attr => {\n #[cfg(feature = \"gecko\")]\n let local_name = LocalName::cast(&reference.name);\n #[cfg(feature = \"servo\")]\n let local_name = LocalName::from(reference.name.as_ref());\n let namespace = match reference.attribute_data.namespace {\n ParsedNamespace::Known(ref ns) => Some(ns),\n ParsedNamespace::Unknown => None,\n };\n namespace\n .and_then(|namespace| attribute_tracker.query(&local_name, namespace))\n .map_or_else(\n || {\n // Special case when fallback and are omitted.\n // See FAILURE: https://drafts.csswg.org/css-values-5/#attr-substitution\n if reference.fallback.is_none()\n && reference.attribute_data.kind == AttributeType::None\n {\n simple_attr_subst(\"\")\n } else {\n None\n }\n },\n |attr| {\n let attr = if let AttributeType::Type(_) = &reference.attribute_data.kind {\n // If we're evaluating a container query, we haven't run the cascade\n // and populated substitution_functions.attributes, so we can't do the\n // get_attr() lookup here.\n // TODO: This means chained attr() references will not work reliably in\n // container style queries:\n // https://bugzilla.mozilla.org/show_bug.cgi?id=2028861\n if computed_context.in_container_query {\n attr\n } else {\n substitution_functions\n .get_attr(&reference.name)\n .map(|v| v.to_variable_value())?\n .css\n }\n } else {\n attr\n };\n let mut input = ParserInput::new(&attr);\n let mut parser = Parser::new(&mut input);\n match &reference.attribute_data.kind {\n AttributeType::Unit(unit) => {\n let css = {\n // Verify that attribute data is a .\n parser.expect_number().ok()?;\n let mut s = attr.clone();\n s.push_str(unit.as_ref());\n s\n };\n let serialization = match unit {\n AttrUnit::Number => TokenSerializationType::Number,\n AttrUnit::Percentage => TokenSerializationType::Percentage,\n _ => TokenSerializationType::Dimension,\n };\n let value =\n ComputedValue::new(css, url_data, serialization, serialization);\n Some(Substitution::from_value(\n value, /* attr_tainted */ true,\n ))\n },\n AttributeType::Type(syntax) => {\n let value = SpecifiedRegisteredValue::parse(\n &mut parser,\n &syntax,\n url_data,\n None,\n AllowComputationallyDependent::Yes,\n AttrTaint::default(),\n )\n .ok()?;\n let value = value.to_variable_value();\n Some(Substitution::from_value(\n value, /* attr_tainted */ true,\n ))\n },\n AttributeType::RawString | AttributeType::None => {\n simple_attr_subst(&attr)\n },\n }\n },\n )\n },\n };\n\n if let Some(s) = substitution {\n // Skip references that are inside the outer variable (in fallback for example).\n while references\n .next_if(|next_ref| next_ref.end <= reference.end)\n .is_some()\n {}\n return Ok(s);\n }\n\n let Some(ref fallback) = reference.fallback else {\n return Err(());\n };\n\n do_substitute_chunk(\n css,\n fallback.start.get(),\n reference.end - 1, // Skip the closing parenthesis of the reference value.\n fallback.first_token_type,\n fallback.last_token_type,\n url_data,\n substitution_functions,\n stylist,\n computed_context,\n references,\n attribute_tracker,\n /* attr_taint */ None,\n )\n}\n\n/// Replace `var()`, `env()`, and `attr()` functions. Return `Err(..)` for invalid at computed time.\nfn substitute_internal<'a>(\n variable_value: &'a VariableValue,\n substitution_functions: &'a ComputedSubstitutionFunctions,\n stylist: &Stylist,\n computed_context: &computed::Context,\n attribute_tracker: &mut AttributeTracker,\n mut attr_taint: Option<&mut AttrTaint>,\n) -> Result, ()> {\n let mut refs = variable_value.references.refs.iter().peekable();\n do_substitute_chunk(\n &variable_value.css,\n /* start = */ 0,\n /* end = */ variable_value.css.len(),\n variable_value.first_token_type,\n variable_value.last_token_type,\n &variable_value.url_data,\n substitution_functions,\n stylist,\n computed_context,\n &mut refs,\n attribute_tracker,\n attr_taint.as_deref_mut(),\n )\n}\n\n/// Replace var(), env(), and attr() functions, returning the resulting CSS string.\npub fn substitute<'a>(\n variable_value: &'a VariableValue,\n substitution_functions: &'a ComputedSubstitutionFunctions,\n stylist: &Stylist,\n computed_context: &computed::Context,\n attribute_tracker: &mut AttributeTracker,\n) -> Result, ()> {\n debug_assert!(variable_value.has_references());\n let mut attr_taint = AttrTaint::default();\n let v = substitute_internal(\n variable_value,\n substitution_functions,\n stylist,\n computed_context,\n attribute_tracker,\n Some(&mut attr_taint),\n )?;\n Ok(SubstitutionResult {\n css: v.css,\n attr_taint,\n })\n}\n" }, { "path": "style/custom_properties_map.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! The structure that contains the custom properties of a given element.\n\nuse crate::custom_properties::{Name, SubstitutionFunctionKind};\nuse crate::properties_and_values::value::ComputedValue as ComputedRegisteredValue;\nuse crate::selector_map::PrecomputedHasher;\nuse indexmap::{Equivalent, IndexMap};\nuse rustc_hash::FxBuildHasher;\nuse servo_arc::Arc;\nuse std::hash::{BuildHasherDefault, Hash};\nuse std::sync::LazyLock;\n\n/// A map for a set of custom properties, which implements copy-on-write behavior on insertion with\n/// cheap copying.\n#[derive(Clone, Debug, PartialEq)]\npub struct CustomPropertiesMap(Arc);\n\nimpl Default for CustomPropertiesMap {\n fn default() -> Self {\n Self(EMPTY.clone())\n }\n}\n\n/// We use None in the value to represent a removed entry.\npub type OwnMap =\n IndexMap, BuildHasherDefault>;\n\nstatic EMPTY: LazyLock> = LazyLock::new(|| {\n Arc::new_leaked(Inner {\n own_properties: Default::default(),\n parent: None,\n len: 0,\n ancestor_count: 0,\n })\n});\n\n#[derive(Debug, Clone)]\nstruct Inner {\n own_properties: OwnMap,\n parent: Option>,\n /// The number of custom properties we store. Note that this is different from the sum of our\n /// own and our parent's length, since we might store duplicate entries.\n len: usize,\n /// The number of ancestors we have.\n ancestor_count: u8,\n}\n\n/// A not-too-large, not too small ancestor limit, to prevent creating too-big chains.\nconst ANCESTOR_COUNT_LIMIT: usize = 4;\n\n/// An iterator over the custom properties.\npub struct Iter<'a> {\n current: &'a Inner,\n current_iter: indexmap::map::Iter<'a, Name, Option>,\n descendants: smallvec::SmallVec<[&'a Inner; ANCESTOR_COUNT_LIMIT]>,\n}\n\nimpl<'a> Iterator for Iter<'a> {\n type Item = (&'a Name, &'a Option);\n\n fn next(&mut self) -> Option {\n loop {\n let (name, value) = match self.current_iter.next() {\n Some(v) => v,\n None => {\n let parent = self.current.parent.as_deref()?;\n self.descendants.push(self.current);\n self.current = parent;\n self.current_iter = parent.own_properties.iter();\n continue;\n },\n };\n // If the property is overridden by a descendant we've already visited it.\n for descendant in &self.descendants {\n if descendant.own_properties.contains_key(name) {\n continue;\n }\n }\n return Some((name, value));\n }\n }\n}\n\nimpl PartialEq for Inner {\n fn eq(&self, other: &Self) -> bool {\n if self.len != other.len {\n return false;\n }\n // NOTE(emilio): In order to speed up custom property comparison when tons of custom\n // properties are involved, we return false in some cases where the ordering might be\n // different, but the computed values end up being the same.\n //\n // This is a performance trade-off, on the assumption that if the ordering is different,\n // there's likely a different value as well, but might over-invalidate.\n //\n // Doing the slow thing (checking all the keys) shows up a lot in profiles, see\n // bug 1926423.\n //\n // Note that self.own_properties != other.own_properties is not the same, as by default\n // IndexMap comparison is not order-aware.\n if self.own_properties.as_slice() != other.own_properties.as_slice() {\n return false;\n }\n self.parent == other.parent\n }\n}\n\nimpl Inner {\n fn iter(&self) -> Iter<'_> {\n Iter {\n current: self,\n current_iter: self.own_properties.iter(),\n descendants: Default::default(),\n }\n }\n\n fn is_empty(&self) -> bool {\n self.len == 0\n }\n\n fn len(&self) -> usize {\n self.len\n }\n\n fn get(&self, name: &Name) -> Option<&ComputedRegisteredValue> {\n if let Some(p) = self.own_properties.get(name) {\n return p.as_ref();\n }\n self.parent.as_ref()?.get(name)\n }\n\n fn insert(&mut self, name: &Name, value: Option) {\n let new = self.own_properties.insert(name.clone(), value).is_none();\n if new && self.parent.as_ref().map_or(true, |p| p.get(name).is_none()) {\n self.len += 1;\n }\n }\n\n /// Whether we should expand the chain, or just copy-on-write.\n fn should_expand_chain(&self) -> bool {\n const SMALL_THRESHOLD: usize = 8;\n if self.own_properties.len() <= SMALL_THRESHOLD {\n return false; // Just copy, to avoid very long chains.\n }\n self.ancestor_count < ANCESTOR_COUNT_LIMIT as u8\n }\n}\n\nimpl CustomPropertiesMap {\n /// Returns whether the map has no properties in it.\n pub fn is_empty(&self) -> bool {\n self.0.is_empty()\n }\n\n /// Returns the amount of different properties in the map.\n pub fn len(&self) -> usize {\n self.0.len()\n }\n\n /// Returns the property name and value at a given index.\n pub fn get_index(&self, index: usize) -> Option<(&Name, &Option)> {\n if index >= self.len() {\n return None;\n }\n // FIXME: This is O(n) which is a bit unfortunate.\n self.0.iter().nth(index)\n }\n\n /// Returns a given property value by name.\n pub fn get(&self, name: &Name) -> Option<&ComputedRegisteredValue> {\n self.0.get(name)\n }\n\n fn do_insert(&mut self, name: &Name, value: Option) {\n if let Some(inner) = Arc::get_mut(&mut self.0) {\n return inner.insert(name, value);\n }\n if self.get(name) == value.as_ref() {\n return;\n }\n if !self.0.should_expand_chain() {\n return Arc::make_mut(&mut self.0).insert(name, value);\n }\n let len = self.0.len;\n let ancestor_count = self.0.ancestor_count + 1;\n let mut new_inner = Inner {\n own_properties: Default::default(),\n // FIXME: Would be nice to avoid this clone.\n parent: Some(self.0.clone()),\n len,\n ancestor_count,\n };\n new_inner.insert(name, value);\n self.0 = Arc::new(new_inner);\n }\n\n /// Inserts an element in the map.\n pub fn insert(&mut self, name: &Name, value: ComputedRegisteredValue) {\n self.do_insert(name, Some(value))\n }\n\n /// Removes an element from the map.\n pub fn remove(&mut self, name: &Name) {\n self.do_insert(name, None)\n }\n\n /// Shrinks the map as much as possible.\n pub fn shrink_to_fit(&mut self) {\n if let Some(inner) = Arc::get_mut(&mut self.0) {\n inner.own_properties.shrink_to_fit()\n }\n }\n\n /// Return iterator to go through all properties.\n pub fn iter(&self) -> Iter<'_> {\n self.0.iter()\n }\n}\n\n/// An `IndexMap` containing both custom properties and attributes.\n#[derive(Clone, Debug, Default, PartialEq)]\npub struct AllSubstitutionFunctions(IndexMap);\n\n#[derive(Clone, Debug, Hash, Eq, PartialEq)]\nstruct Key(Name, SubstitutionFunctionKind);\n\n#[derive(Clone, Debug, Hash, Eq, PartialEq)]\nstruct KeyRef<'a>(&'a Name, SubstitutionFunctionKind);\n\nimpl<'a> Equivalent for KeyRef<'a> {\n fn equivalent(&self, key: &Key) -> bool {\n *self.0 == key.0 && self.1 == key.1\n }\n}\n\nimpl AllSubstitutionFunctions {\n /// Returns whether the map has zero properties and attributes in it.\n #[inline(always)]\n pub fn is_empty(&self) -> bool {\n self.0.is_empty()\n }\n\n /// Returns a custom property or attribute value by name.\n #[inline(always)]\n pub fn get(\n &self,\n name: &Name,\n kind: SubstitutionFunctionKind,\n ) -> Option<&ComputedRegisteredValue> {\n debug_assert_ne!(kind, SubstitutionFunctionKind::Env);\n self.0.get(&KeyRef(name, kind))\n }\n\n /// Inserts an element into the map.\n #[inline(always)]\n pub fn insert(\n &mut self,\n name: &Name,\n kind: SubstitutionFunctionKind,\n value: ComputedRegisteredValue,\n ) {\n debug_assert_ne!(kind, SubstitutionFunctionKind::Env);\n let k = Key(name.clone(), kind);\n self.0.insert(k, value);\n }\n\n /// Returns iterator to go through all substitution functions in insertion order.\n #[inline(always)]\n pub fn iter(\n &self,\n ) -> impl Iterator {\n self.0.iter().map(|(k, v)| (&k.0, k.1, v))\n }\n}\n" }, { "path": "style/data.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! Per-node data used in style calculation.\n\nuse crate::computed_value_flags::ComputedValueFlags;\nuse crate::context::{SharedStyleContext, StackLimitChecker};\nuse crate::dom::TElement;\nuse crate::invalidation::element::invalidator::InvalidationResult;\nuse crate::invalidation::element::restyle_hints::RestyleHint;\nuse crate::properties::ComputedValues;\nuse crate::selector_parser::{PseudoElement, RestyleDamage, EAGER_PSEUDO_COUNT};\nuse crate::style_resolver::{PrimaryStyle, ResolvedElementStyles, ResolvedStyle};\n#[cfg(feature = \"gecko\")]\nuse malloc_size_of::MallocSizeOfOps;\nuse selectors::matching::SelectorCaches;\nuse servo_arc::Arc;\nuse std::ops::{Deref, DerefMut};\nuse std::{fmt, mem};\n\n#[cfg(debug_assertions)]\nuse atomic_refcell::{AtomicRef, AtomicRefCell, AtomicRefMut};\n\nbitflags! {\n /// Various flags stored on ElementData.\n #[derive(Debug, Default)]\n pub struct ElementDataFlags: u8 {\n /// Whether the styles changed for this restyle.\n const WAS_RESTYLED = 1 << 0;\n /// Whether the last traversal of this element did not do\n /// any style computation. This is not true during the initial\n /// styling pass, nor is it true when we restyle (in which case\n /// WAS_RESTYLED is set).\n ///\n /// This bit always corresponds to the last time the element was\n /// traversed, so each traversal simply updates it with the appropriate\n /// value.\n const TRAVERSED_WITHOUT_STYLING = 1 << 1;\n\n /// Whether the primary style of this element data was reused from\n /// another element via a rule node comparison. This allows us to\n /// differentiate between elements that shared styles because they met\n /// all the criteria of the style sharing cache, compared to elements\n /// that reused style structs via rule node identity.\n ///\n /// The former gives us stronger transitive guarantees that allows us to\n /// apply the style sharing cache to cousins.\n const PRIMARY_STYLE_REUSED_VIA_RULE_NODE = 1 << 2;\n }\n}\n\n/// A lazily-allocated list of styles for eagerly-cascaded pseudo-elements.\n///\n/// We use an Arc so that sharing these styles via the style sharing cache does\n/// not require duplicate allocations. We leverage the copy-on-write semantics of\n/// Arc::make_mut(), which is free (i.e. does not require atomic RMU operations)\n/// in servo_arc.\n#[derive(Clone, Debug, Default)]\npub struct EagerPseudoStyles(Option>);\n\n#[derive(Default)]\nstruct EagerPseudoArray(EagerPseudoArrayInner);\ntype EagerPseudoArrayInner = [Option>; EAGER_PSEUDO_COUNT];\n\nimpl Deref for EagerPseudoArray {\n type Target = EagerPseudoArrayInner;\n fn deref(&self) -> &Self::Target {\n &self.0\n }\n}\n\nimpl DerefMut for EagerPseudoArray {\n fn deref_mut(&mut self) -> &mut Self::Target {\n &mut self.0\n }\n}\n\n// Manually implement `Clone` here because the derived impl of `Clone` for\n// array types assumes the value inside is `Copy`.\nimpl Clone for EagerPseudoArray {\n fn clone(&self) -> Self {\n let mut clone = Self::default();\n for i in 0..EAGER_PSEUDO_COUNT {\n clone[i] = self.0[i].clone();\n }\n clone\n }\n}\n\n// Override Debug to print which pseudos we have, and substitute the rule node\n// for the much-more-verbose ComputedValues stringification.\nimpl fmt::Debug for EagerPseudoArray {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n write!(f, \"EagerPseudoArray {{ \")?;\n for i in 0..EAGER_PSEUDO_COUNT {\n if let Some(ref values) = self[i] {\n write!(\n f,\n \"{:?}: {:?}, \",\n PseudoElement::from_eager_index(i),\n &values.rules\n )?;\n }\n }\n write!(f, \"}}\")\n }\n}\n\n// Can't use [None; EAGER_PSEUDO_COUNT] here because it complains\n// about Copy not being implemented for our Arc type.\nconst EMPTY_PSEUDO_ARRAY: &'static EagerPseudoArrayInner = &[None, None, None, None];\n\nimpl EagerPseudoStyles {\n /// Returns whether there are any pseudo styles.\n pub fn is_empty(&self) -> bool {\n self.0.is_none()\n }\n\n /// Grabs a reference to the list of styles, if they exist.\n pub fn as_optional_array(&self) -> Option<&EagerPseudoArrayInner> {\n match self.0 {\n None => None,\n Some(ref x) => Some(&x.0),\n }\n }\n\n /// Grabs a reference to the list of styles or a list of None if\n /// there are no styles to be had.\n pub fn as_array(&self) -> &EagerPseudoArrayInner {\n self.as_optional_array().unwrap_or(EMPTY_PSEUDO_ARRAY)\n }\n\n /// Returns a reference to the style for a given eager pseudo, if it exists.\n pub fn get(&self, pseudo: &PseudoElement) -> Option<&Arc> {\n debug_assert!(pseudo.is_eager());\n self.0\n .as_ref()\n .and_then(|p| p[pseudo.eager_index()].as_ref())\n }\n\n /// Sets the style for the eager pseudo.\n pub fn set(&mut self, pseudo: &PseudoElement, value: Arc) {\n if self.0.is_none() {\n self.0 = Some(Arc::new(Default::default()));\n }\n let arr = Arc::make_mut(self.0.as_mut().unwrap());\n arr[pseudo.eager_index()] = Some(value);\n }\n}\n\n/// The styles associated with a node, including the styles for any\n/// pseudo-elements.\n#[derive(Clone, Default)]\npub struct ElementStyles {\n /// The element's style.\n pub primary: Option>,\n /// A list of the styles for the element's eagerly-cascaded pseudo-elements.\n pub pseudos: EagerPseudoStyles,\n}\n\n// There's one of these per rendered elements so it better be small.\nsize_of_test!(ElementStyles, 16);\n\n/// Information on how this element uses viewport units.\n#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]\npub enum ViewportUnitUsage {\n /// No viewport units are used.\n None = 0,\n /// There are viewport units used from regular style rules (which means we\n /// should re-cascade).\n FromDeclaration,\n /// There are viewport units used from container queries (which means we\n /// need to re-selector-match).\n FromQuery,\n}\n\nimpl ElementStyles {\n /// Returns the primary style.\n pub fn get_primary(&self) -> Option<&Arc> {\n self.primary.as_ref()\n }\n\n /// Returns the primary style. Panic if no style available.\n pub fn primary(&self) -> &Arc {\n self.primary.as_ref().unwrap()\n }\n\n /// Whether this element `display` value is `none`.\n pub fn is_display_none(&self) -> bool {\n self.primary().get_box().clone_display().is_none()\n }\n\n /// Whether this element uses viewport units.\n pub fn viewport_unit_usage(&self) -> ViewportUnitUsage {\n fn usage_from_flags(flags: ComputedValueFlags) -> ViewportUnitUsage {\n if flags.intersects(ComputedValueFlags::USES_VIEWPORT_UNITS_ON_CONTAINER_QUERIES) {\n return ViewportUnitUsage::FromQuery;\n }\n if flags.intersects(ComputedValueFlags::USES_VIEWPORT_UNITS) {\n return ViewportUnitUsage::FromDeclaration;\n }\n ViewportUnitUsage::None\n }\n\n let primary = self.primary();\n let mut usage = usage_from_flags(primary.flags);\n\n // Check cached lazy pseudos on the primary style.\n primary.each_cached_lazy_pseudo(|style| {\n usage = std::cmp::max(usage, usage_from_flags(style.flags));\n });\n\n for pseudo_style in self.pseudos.as_array() {\n if let Some(ref pseudo_style) = pseudo_style {\n usage = std::cmp::max(usage, usage_from_flags(pseudo_style.flags));\n // Also check cached lazy pseudos on eager pseudo styles.\n pseudo_style.each_cached_lazy_pseudo(|style| {\n usage = std::cmp::max(usage, usage_from_flags(style.flags));\n });\n }\n }\n\n usage\n }\n\n #[cfg(feature = \"gecko\")]\n fn size_of_excluding_cvs(&self, _ops: &mut MallocSizeOfOps) -> usize {\n // As the method name suggests, we don't measures the ComputedValues\n // here, because they are measured on the C++ side.\n\n // XXX: measure the EagerPseudoArray itself, but not the ComputedValues\n // within it.\n\n 0\n }\n}\n\n// We manually implement Debug for ElementStyles so that we can avoid the\n// verbose stringification of every property in the ComputedValues. We\n// substitute the rule node instead.\nimpl fmt::Debug for ElementStyles {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n write!(\n f,\n \"ElementStyles {{ primary: {:?}, pseudos: {:?} }}\",\n self.primary.as_ref().map(|x| &x.rules),\n self.pseudos\n )\n }\n}\n\n/// Style system data associated with an Element.\n///\n/// In Gecko, this hangs directly off the Element. Servo, this is embedded\n/// inside of layout data, which itself hangs directly off the Element. In\n/// both cases, it is wrapped inside an AtomicRefCell to ensure thread safety.\n#[derive(Debug, Default)]\npub struct ElementData {\n /// The styles for the element and its pseudo-elements.\n pub styles: ElementStyles,\n\n /// The restyle damage, indicating what kind of layout changes are required\n /// afte restyling.\n pub damage: RestyleDamage,\n\n /// The restyle hint, which indicates whether selectors need to be rematched\n /// for this element, its children, and its descendants.\n pub hint: RestyleHint,\n\n /// Flags.\n pub flags: ElementDataFlags,\n}\n\n/// A struct that wraps ElementData, giving it the ability of doing thread-safety checks.\n#[derive(Debug, Default)]\npub struct ElementDataWrapper {\n inner: std::cell::UnsafeCell,\n /// Implements optional (debug_assertions-only) thread-safety checking.\n #[cfg(debug_assertions)]\n refcell: AtomicRefCell<()>,\n}\n\n/// A read-only reference to ElementData.\n#[derive(Debug)]\npub struct ElementDataMut<'a> {\n v: &'a mut ElementData,\n #[cfg(debug_assertions)]\n _borrow: AtomicRefMut<'a, ()>,\n}\n\n/// A mutable reference to ElementData.\n#[derive(Debug)]\npub struct ElementDataRef<'a> {\n v: &'a ElementData,\n #[cfg(debug_assertions)]\n _borrow: AtomicRef<'a, ()>,\n}\n\nimpl ElementDataWrapper {\n /// Gets a non-exclusive reference to this ElementData.\n #[inline(always)]\n pub fn borrow(&self) -> ElementDataRef<'_> {\n #[cfg(debug_assertions)]\n let borrow = self.refcell.borrow();\n ElementDataRef {\n v: unsafe { &*self.inner.get() },\n #[cfg(debug_assertions)]\n _borrow: borrow,\n }\n }\n\n /// Gets an exclusive reference to this ElementData.\n #[inline(always)]\n pub fn borrow_mut(&self) -> ElementDataMut<'_> {\n #[cfg(debug_assertions)]\n let borrow = self.refcell.borrow_mut();\n ElementDataMut {\n v: unsafe { &mut *self.inner.get() },\n #[cfg(debug_assertions)]\n _borrow: borrow,\n }\n }\n}\n\nimpl<'a> Deref for ElementDataRef<'a> {\n type Target = ElementData;\n #[inline]\n fn deref(&self) -> &Self::Target {\n &*self.v\n }\n}\n\nimpl<'a> Deref for ElementDataMut<'a> {\n type Target = ElementData;\n #[inline]\n fn deref(&self) -> &Self::Target {\n &*self.v\n }\n}\n\nimpl<'a> DerefMut for ElementDataMut<'a> {\n fn deref_mut(&mut self) -> &mut Self::Target {\n &mut *self.v\n }\n}\n\n// There's one of these per rendered elements so it better be small.\nsize_of_test!(ElementData, 24);\n\n/// The kind of restyle that a single element should do.\n#[derive(Debug)]\npub enum RestyleKind {\n /// We need to run selector matching plus re-cascade, that is, a full\n /// restyle.\n MatchAndCascade,\n /// We need to recascade with some replacement rule, such as the style\n /// attribute, or animation rules.\n CascadeWithReplacements(RestyleHint),\n /// We only need to recascade, for example, because only inherited\n /// properties in the parent changed.\n CascadeOnly,\n}\n\nfn needs_to_match_self(hint: RestyleHint, style: &ComputedValues) -> bool {\n if hint.intersects(RestyleHint::RESTYLE_SELF) {\n return true;\n }\n if hint.intersects(RestyleHint::RESTYLE_SELF_IF_PSEUDO) && style.is_pseudo_style() {\n return true;\n }\n if hint.intersects(RestyleHint::RESTYLE_IF_AFFECTED_BY_ANCESTOR_FONT_METRICS)\n && style\n .flags\n .contains(ComputedValueFlags::DEPENDS_ON_FONT_METRICS_IN_CONTAINER_QUERY)\n {\n return true;\n }\n hint.intersects(\n RestyleHint::RESTYLE_IF_AFFECTED_BY_STYLE_QUERIES\n | RestyleHint::RESTYLE_IF_AFFECTED_BY_NAMED_STYLE_CONTAINER,\n ) && style\n .flags\n .contains(ComputedValueFlags::DEPENDS_ON_CONTAINER_STYLE_QUERY)\n}\n\nimpl ElementData {\n /// Invalidates style for this element, its descendants, and later siblings,\n /// based on the snapshot of the element that we took when attributes or\n /// state changed.\n pub fn invalidate_style_if_needed<'a, E: TElement>(\n &mut self,\n element: E,\n shared_context: &SharedStyleContext,\n stack_limit_checker: Option<&StackLimitChecker>,\n selector_caches: &'a mut SelectorCaches,\n ) -> InvalidationResult {\n // In animation-only restyle we shouldn't touch snapshot at all.\n if shared_context.traversal_flags.for_animation_only() {\n return InvalidationResult::empty();\n }\n\n use crate::invalidation::element::invalidator::TreeStyleInvalidator;\n use crate::invalidation::element::state_and_attributes::StateAndAttrInvalidationProcessor;\n\n debug!(\n \"invalidate_style_if_needed: {:?}, flags: {:?}, has_snapshot: {}, \\\n handled_snapshot: {}, pseudo: {:?}\",\n element,\n shared_context.traversal_flags,\n element.has_snapshot(),\n element.handled_snapshot(),\n element.implemented_pseudo_element()\n );\n\n if !element.has_snapshot() || element.handled_snapshot() {\n return InvalidationResult::empty();\n }\n\n let mut processor =\n StateAndAttrInvalidationProcessor::new(shared_context, element, self, selector_caches);\n\n let invalidator = TreeStyleInvalidator::new(element, stack_limit_checker, &mut processor);\n\n let result = invalidator.invalidate();\n\n unsafe { element.set_handled_snapshot() }\n debug_assert!(element.handled_snapshot());\n\n result\n }\n\n /// Returns true if this element has styles.\n #[inline]\n pub fn has_styles(&self) -> bool {\n self.styles.primary.is_some()\n }\n\n /// Returns this element's styles as resolved styles to use for sharing.\n pub fn share_styles(&self) -> ResolvedElementStyles {\n ResolvedElementStyles {\n primary: self.share_primary_style(),\n pseudos: self.styles.pseudos.clone(),\n }\n }\n\n /// Returns this element's primary style as a resolved style to use for sharing.\n pub fn share_primary_style(&self) -> PrimaryStyle {\n let reused_via_rule_node = self\n .flags\n .contains(ElementDataFlags::PRIMARY_STYLE_REUSED_VIA_RULE_NODE);\n\n PrimaryStyle {\n style: ResolvedStyle(self.styles.primary().clone()),\n reused_via_rule_node,\n }\n }\n\n /// Return a copy of the element's primary style as a resolved style with the\n /// given flags.\n pub fn clone_style_with_flags(&self, flags: ComputedValueFlags) -> ResolvedStyle {\n let primary_style = self.styles.primary();\n // We are only using this pseudo to find the correct pseudo type so it\n // does not matter it technically belongs to a different style.\n let pseudo = primary_style.pseudo();\n ResolvedStyle(\n primary_style\n .deref()\n .clone_with_flags(flags, pseudo.as_ref()),\n )\n }\n\n /// Sets a new set of styles, returning the old ones.\n pub fn set_styles(&mut self, new_styles: ResolvedElementStyles) -> ElementStyles {\n self.flags.set(\n ElementDataFlags::PRIMARY_STYLE_REUSED_VIA_RULE_NODE,\n new_styles.primary.reused_via_rule_node,\n );\n mem::replace(&mut self.styles, new_styles.into())\n }\n\n /// Returns the kind of restyling that we're going to need to do on this\n /// element, based of the stored restyle hint.\n pub fn restyle_kind(&self, shared_context: &SharedStyleContext) -> Option {\n let style = match self.styles.primary {\n Some(ref s) => s,\n None => return Some(RestyleKind::MatchAndCascade),\n };\n\n if shared_context.traversal_flags.for_animation_only() {\n return self.restyle_kind_for_animation(shared_context);\n }\n\n let hint = self.hint;\n if hint.is_empty() {\n return None;\n }\n\n if needs_to_match_self(hint, style) {\n return Some(RestyleKind::MatchAndCascade);\n }\n\n if hint.has_replacements() {\n debug_assert!(\n !hint.has_animation_hint(),\n \"Animation only restyle hint should have already processed\"\n );\n return Some(RestyleKind::CascadeWithReplacements(\n hint & RestyleHint::replacements(),\n ));\n }\n\n let needs_to_recascade_self = hint.intersects(RestyleHint::RECASCADE_SELF)\n || (hint.intersects(RestyleHint::RECASCADE_SELF_IF_INHERIT_RESET_STYLE)\n && style\n .flags\n .contains(ComputedValueFlags::INHERITS_RESET_STYLE));\n if needs_to_recascade_self {\n return Some(RestyleKind::CascadeOnly);\n }\n\n None\n }\n\n /// Returns the kind of restyling for animation-only restyle.\n fn restyle_kind_for_animation(\n &self,\n shared_context: &SharedStyleContext,\n ) -> Option {\n debug_assert!(shared_context.traversal_flags.for_animation_only());\n debug_assert!(self.has_styles());\n\n // FIXME: We should ideally restyle here, but it is a hack to work around our weird\n // animation-only traversal stuff: If we're display: none and the rules we could\n // match could change, we consider our style up-to-date. This is because re-cascading with\n // and old style doesn't guarantee returning the correct animation style (that's\n // bug 1393323). So if our display changed, and it changed from display: none, we would\n // incorrectly forget about it and wouldn't be able to correctly style our descendants\n // later.\n // XXX Figure out if this still makes sense.\n let hint = self.hint;\n if self.styles.is_display_none() && hint.intersects(RestyleHint::RESTYLE_SELF) {\n return None;\n }\n\n let style = self.styles.primary();\n // Return either CascadeWithReplacements or CascadeOnly in case of animation-only restyle.\n // I.e. animation-only restyle never does selector matching.\n if hint.has_animation_hint() {\n return Some(RestyleKind::CascadeWithReplacements(\n hint & RestyleHint::for_animations(),\n ));\n }\n\n let needs_to_recascade_self = hint.intersects(RestyleHint::RECASCADE_SELF)\n || (hint.intersects(RestyleHint::RECASCADE_SELF_IF_INHERIT_RESET_STYLE)\n && style\n .flags\n .contains(ComputedValueFlags::INHERITS_RESET_STYLE));\n if needs_to_recascade_self {\n return Some(RestyleKind::CascadeOnly);\n }\n return None;\n }\n\n /// Drops any restyle state from the element.\n ///\n /// FIXME(bholley): The only caller of this should probably just assert that the hint is empty\n /// and call clear_flags_and_damage().\n #[inline]\n pub fn clear_restyle_state(&mut self) {\n self.hint = RestyleHint::empty();\n self.clear_restyle_flags_and_damage();\n }\n\n /// Drops restyle flags and damage from the element.\n #[inline]\n pub fn clear_restyle_flags_and_damage(&mut self) {\n self.damage = RestyleDamage::empty();\n self.flags.remove(ElementDataFlags::WAS_RESTYLED);\n }\n\n /// Mark this element as restyled, which is useful to know whether we need\n /// to do a post-traversal.\n pub fn set_restyled(&mut self) {\n self.flags.insert(ElementDataFlags::WAS_RESTYLED);\n self.flags\n .remove(ElementDataFlags::TRAVERSED_WITHOUT_STYLING);\n }\n\n /// Returns true if this element was restyled.\n #[inline]\n pub fn is_restyle(&self) -> bool {\n self.flags.contains(ElementDataFlags::WAS_RESTYLED)\n }\n\n /// Mark that we traversed this element without computing any style for it.\n pub fn set_traversed_without_styling(&mut self) {\n self.flags\n .insert(ElementDataFlags::TRAVERSED_WITHOUT_STYLING);\n }\n\n /// Returns whether this element has been part of a restyle.\n #[inline]\n pub fn contains_restyle_data(&self) -> bool {\n self.is_restyle() || !self.hint.is_empty() || !self.damage.is_empty()\n }\n\n /// Returns whether it is safe to perform cousin sharing based on the ComputedValues\n /// identity of the primary style in this ElementData. There are a few subtle things\n /// to check.\n ///\n /// First, if a parent element was already styled and we traversed past it without\n /// restyling it, that may be because our clever invalidation logic was able to prove\n /// that the styles of that element would remain unchanged despite changes to the id\n /// or class attributes. However, style sharing relies on the strong guarantee that all\n /// the classes and ids up the respective parent chains are identical. As such, if we\n /// skipped styling for one (or both) of the parents on this traversal, we can't share\n /// styles across cousins. Note that this is a somewhat conservative check. We could\n /// tighten it by having the invalidation logic explicitly flag elements for which it\n /// ellided styling.\n ///\n /// Second, we want to only consider elements whose ComputedValues match due to a hit\n /// in the style sharing cache, rather than due to the rule-node-based reuse that\n /// happens later in the styling pipeline. The former gives us the stronger guarantees\n /// we need for style sharing, the latter does not.\n pub fn safe_for_cousin_sharing(&self) -> bool {\n if self.flags.intersects(\n ElementDataFlags::TRAVERSED_WITHOUT_STYLING\n | ElementDataFlags::PRIMARY_STYLE_REUSED_VIA_RULE_NODE,\n ) {\n return false;\n }\n if !self\n .styles\n .primary()\n .get_box()\n .clone_container_type()\n .is_normal()\n {\n return false;\n }\n true\n }\n\n /// Measures memory usage.\n #[cfg(feature = \"gecko\")]\n pub fn size_of_excluding_cvs(&self, ops: &mut MallocSizeOfOps) -> usize {\n let n = self.styles.size_of_excluding_cvs(ops);\n\n // We may measure more fields in the future if DMD says it's worth it.\n\n n\n }\n}\n" }, { "path": "style/device/gecko.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! Gecko-specific logic for [`Device`].\n\nuse crate::color::AbsoluteColor;\nuse crate::context::QuirksMode;\nuse crate::custom_properties::CssEnvironment;\nuse crate::device::Device;\nuse crate::font_metrics::FontMetrics;\nuse crate::gecko::wrapper::GeckoElement;\nuse crate::gecko_bindings::bindings;\nuse crate::gecko_bindings::structs;\nuse crate::logical_geometry::WritingMode;\nuse crate::media_queries::MediaType;\nuse crate::properties::ComputedValues;\nuse crate::string_cache::Atom;\nuse crate::values::computed::font::GenericFontFamily;\nuse crate::values::computed::{ColorScheme, Length, NonNegativeLength};\nuse crate::values::specified::color::{ColorSchemeFlags, ForcedColors, SystemColor};\nuse crate::values::specified::font::{\n QueryFontMetricsFlags, FONT_MEDIUM_CAP_PX, FONT_MEDIUM_CH_PX, FONT_MEDIUM_EX_PX,\n FONT_MEDIUM_IC_PX, FONT_MEDIUM_LINE_HEIGHT_PX, FONT_MEDIUM_PX,\n};\nuse crate::values::specified::ViewportVariant;\nuse crate::values::{CustomIdent, KeyframesName};\nuse app_units::{Au, AU_PER_PX};\nuse euclid::default::Size2D;\nuse euclid::{Scale, SideOffsets2D};\nuse parking_lot::RwLock;\nuse servo_arc::Arc;\nuse std::sync::atomic::{AtomicBool, AtomicU32, Ordering};\nuse std::{cmp, fmt};\nuse style_traits::{CSSPixel, DevicePixel};\n\npub(super) struct ExtraDeviceData {\n /// NB: The document owns the styleset, who owns the stylist, and thus the\n /// `Device`, so having a raw document pointer here is fine.\n document: *const structs::Document,\n}\n\nunsafe impl Sync for Device {}\nunsafe impl Send for Device {}\n\nimpl Device {\n /// Trivially constructs a new `Device`.\n pub fn new(document: *const structs::Document) -> Self {\n assert!(!document.is_null());\n let doc = unsafe { &*document };\n let prefs = unsafe { &*bindings::Gecko_GetPrefSheetPrefs(doc) };\n let default_values = ComputedValues::default_values(doc);\n let root_style = RwLock::new(Arc::clone(&default_values));\n Device {\n default_values: default_values,\n root_style: root_style,\n root_font_size: AtomicU32::new(FONT_MEDIUM_PX.to_bits()),\n root_line_height: AtomicU32::new(FONT_MEDIUM_LINE_HEIGHT_PX.to_bits()),\n root_font_metrics_ex: AtomicU32::new(FONT_MEDIUM_EX_PX.to_bits()),\n root_font_metrics_cap: AtomicU32::new(FONT_MEDIUM_CAP_PX.to_bits()),\n root_font_metrics_ch: AtomicU32::new(FONT_MEDIUM_CH_PX.to_bits()),\n root_font_metrics_ic: AtomicU32::new(FONT_MEDIUM_IC_PX.to_bits()),\n used_root_font_size: AtomicBool::new(false),\n used_root_line_height: AtomicBool::new(false),\n used_root_font_metrics: RwLock::new(false),\n used_font_metrics: AtomicBool::new(false),\n used_viewport_size: AtomicBool::new(false),\n used_dynamic_viewport_size: AtomicBool::new(false),\n environment: CssEnvironment,\n // This gets updated when we see the , so it doesn't really\n // matter which color-scheme we look at here.\n body_text_color: AtomicU32::new(prefs.mLightColors.mDefault),\n extra: ExtraDeviceData { document },\n }\n }\n\n /// Returns the computed line-height for the font in a given computed values instance.\n ///\n /// If you pass down an element, then the used line-height is returned.\n pub fn calc_line_height(\n &self,\n font: &crate::properties::style_structs::Font,\n writing_mode: WritingMode,\n element: Option,\n ) -> NonNegativeLength {\n let pres_context = self.pres_context();\n let line_height = font.clone_line_height();\n let au = Au(unsafe {\n bindings::Gecko_CalcLineHeight(\n &line_height,\n pres_context.map_or(std::ptr::null(), |pc| pc),\n writing_mode.is_text_vertical(),\n &**font,\n element.map_or(std::ptr::null(), |e| e.0),\n )\n });\n NonNegativeLength::new(au.to_f32_px())\n }\n\n /// Whether any animation name may be referenced from the style of any\n /// element.\n pub fn animation_name_may_be_referenced(&self, name: &KeyframesName) -> bool {\n let pc = match self.pres_context() {\n Some(pc) => pc,\n None => return false,\n };\n\n unsafe {\n bindings::Gecko_AnimationNameMayBeReferencedFromStyle(pc, name.as_atom().as_ptr())\n }\n }\n\n /// The quirks mode of the document.\n pub fn quirks_mode(&self) -> QuirksMode {\n self.document().mCompatMode.into()\n }\n\n /// Gets the base size given a generic font family and a language.\n pub fn base_size_for_generic(&self, language: &Atom, generic: GenericFontFamily) -> Length {\n unsafe { bindings::Gecko_GetBaseSize(self.document(), language.as_ptr(), generic) }\n }\n\n /// Gets the size of the scrollbar in CSS pixels.\n pub fn scrollbar_inline_size(&self) -> Length {\n let pc = match self.pres_context() {\n Some(pc) => pc,\n // XXX: we could have a more reasonable default perhaps.\n None => return Length::new(0.0),\n };\n Length::new(unsafe { bindings::Gecko_GetScrollbarInlineSize(pc) })\n }\n\n /// Queries font metrics\n pub fn query_font_metrics(\n &self,\n vertical: bool,\n font: &crate::properties::style_structs::Font,\n base_size: Length,\n flags: QueryFontMetricsFlags,\n track_usage: bool,\n ) -> FontMetrics {\n if track_usage {\n self.used_font_metrics.store(true, Ordering::Relaxed);\n }\n let pc = match self.pres_context() {\n Some(pc) => pc,\n None => return Default::default(),\n };\n let gecko_metrics =\n unsafe { bindings::Gecko_GetFontMetrics(pc, vertical, &**font, base_size, flags) };\n FontMetrics {\n x_height: Some(gecko_metrics.mXSize),\n zero_advance_measure: if gecko_metrics.mChSize.px() >= 0. {\n Some(gecko_metrics.mChSize)\n } else {\n None\n },\n cap_height: if gecko_metrics.mCapHeight.px() >= 0. {\n Some(gecko_metrics.mCapHeight)\n } else {\n None\n },\n ic_width: if gecko_metrics.mIcWidth.px() >= 0. {\n Some(gecko_metrics.mIcWidth)\n } else {\n None\n },\n ascent: gecko_metrics.mAscent,\n script_percent_scale_down: if gecko_metrics.mScriptPercentScaleDown > 0. {\n Some(gecko_metrics.mScriptPercentScaleDown)\n } else {\n None\n },\n script_script_percent_scale_down: if gecko_metrics.mScriptScriptPercentScaleDown > 0. {\n Some(gecko_metrics.mScriptScriptPercentScaleDown)\n } else {\n None\n },\n }\n }\n\n /// Gets the document pointer.\n #[inline]\n pub fn document(&self) -> &structs::Document {\n unsafe { &*self.extra.document }\n }\n\n /// Gets the pres context associated with this document.\n #[inline]\n pub fn pres_context(&self) -> Option<&structs::nsPresContext> {\n unsafe {\n self.document()\n .mPresShell\n .as_ref()?\n .mPresContext\n .mRawPtr\n .as_ref()\n }\n }\n\n /// Gets the preference stylesheet prefs for our document.\n #[inline]\n pub fn pref_sheet_prefs(&self) -> &structs::PreferenceSheet_Prefs {\n unsafe { &*bindings::Gecko_GetPrefSheetPrefs(self.document()) }\n }\n\n /// Recreates the default computed values.\n pub fn reset_computed_values(&mut self) {\n self.default_values = ComputedValues::default_values(self.document());\n }\n\n /// Rebuild all the cached data.\n pub fn rebuild_cached_data(&mut self) {\n self.reset_computed_values();\n self.used_root_font_size.store(false, Ordering::Relaxed);\n self.used_root_line_height.store(false, Ordering::Relaxed);\n self.used_root_font_metrics = RwLock::new(false);\n self.used_font_metrics.store(false, Ordering::Relaxed);\n self.used_viewport_size.store(false, Ordering::Relaxed);\n self.used_dynamic_viewport_size\n .store(false, Ordering::Relaxed);\n }\n\n /// Recreates all the temporary state that the `Device` stores.\n ///\n /// This includes the viewport override from `@viewport` rules, and also the\n /// default computed values.\n pub fn reset(&mut self) {\n self.reset_computed_values();\n }\n\n /// Returns whether this document is in print preview.\n pub fn is_print_preview(&self) -> bool {\n let pc = match self.pres_context() {\n Some(pc) => pc,\n None => return false,\n };\n pc.mType == structs::nsPresContext_nsPresContextType_eContext_PrintPreview\n }\n\n /// Returns the current media type of the device.\n pub fn media_type(&self) -> MediaType {\n let pc = match self.pres_context() {\n Some(pc) => pc,\n None => return MediaType::screen(),\n };\n\n // Gecko allows emulating random media with mMediaEmulationData.mMedium.\n let medium_to_use = if !pc.mMediaEmulationData.mMedium.mRawPtr.is_null() {\n pc.mMediaEmulationData.mMedium.mRawPtr\n } else {\n pc.mMedium as *const structs::nsAtom as *mut _\n };\n\n MediaType(CustomIdent(unsafe { Atom::from_raw(medium_to_use) }))\n }\n\n // It may make sense to account for @page rule margins here somehow, however\n // it's not clear how that'd work, see:\n // https://github.com/w3c/csswg-drafts/issues/5437\n fn page_size_minus_default_margin(&self, pc: &structs::nsPresContext) -> Size2D {\n debug_assert!(pc.mIsRootPaginatedDocument() != 0);\n let area = &pc.mPageSize;\n let margin = &pc.mDefaultPageMargin;\n let width = area.width - margin.left - margin.right;\n let height = area.height - margin.top - margin.bottom;\n Size2D::new(Au(cmp::max(width, 0)), Au(cmp::max(height, 0)))\n }\n\n /// Returns the current viewport size in app units.\n pub fn au_viewport_size(&self) -> Size2D {\n let pc = match self.pres_context() {\n Some(pc) => pc,\n None => return Size2D::new(Au(0), Au(0)),\n };\n\n if pc.mIsRootPaginatedDocument() != 0 {\n return self.page_size_minus_default_margin(pc);\n }\n\n let area = &pc.mVisibleArea;\n Size2D::new(Au(area.width), Au(area.height))\n }\n\n /// Returns the current viewport size in app units, recording that it's been\n /// used for viewport unit resolution.\n pub fn au_viewport_size_for_viewport_unit_resolution(\n &self,\n variant: ViewportVariant,\n ) -> Size2D {\n self.used_viewport_size.store(true, Ordering::Relaxed);\n let pc = match self.pres_context() {\n Some(pc) => pc,\n None => return Size2D::new(Au(0), Au(0)),\n };\n\n if pc.mIsRootPaginatedDocument() != 0 {\n return self.page_size_minus_default_margin(pc);\n }\n\n match variant {\n ViewportVariant::UADefault => {\n let size = &pc.mSizeForViewportUnits;\n Size2D::new(Au(size.width), Au(size.height))\n },\n ViewportVariant::Small => {\n let size = &pc.mVisibleArea;\n Size2D::new(Au(size.width), Au(size.height))\n },\n ViewportVariant::Large => {\n let size = &pc.mVisibleArea;\n // Looks like IntCoordTyped is treated as if it's u32 in Rust.\n debug_assert!(\n /* pc.mDynamicToolbarMaxHeight >=0 && */\n pc.mDynamicToolbarMaxHeight < i32::MAX as u32\n );\n Size2D::new(\n Au(size.width),\n Au(size.height\n + pc.mDynamicToolbarMaxHeight as i32 * pc.mCurAppUnitsPerDevPixel),\n )\n },\n ViewportVariant::Dynamic => {\n self.used_dynamic_viewport_size\n .store(true, Ordering::Relaxed);\n let size = &pc.mVisibleArea;\n // Looks like IntCoordTyped is treated as if it's u32 in Rust.\n debug_assert!(\n /* pc.mDynamicToolbarHeight >=0 && */\n pc.mDynamicToolbarHeight < i32::MAX as u32\n );\n Size2D::new(\n Au(size.width),\n Au(size.height\n + (pc.mDynamicToolbarMaxHeight - pc.mDynamicToolbarHeight) as i32\n * pc.mCurAppUnitsPerDevPixel),\n )\n },\n }\n }\n\n /// Returns whether visited styles are enabled.\n pub fn visited_styles_enabled(&self) -> bool {\n unsafe { bindings::Gecko_VisitedStylesEnabled(self.document()) }\n }\n\n /// Returns the number of app units per device pixel we're using currently.\n pub fn app_units_per_device_pixel(&self) -> i32 {\n match self.pres_context() {\n Some(pc) => pc.mCurAppUnitsPerDevPixel,\n None => AU_PER_PX,\n }\n }\n\n /// Returns app units per pixel at 1x full-zoom.\n fn app_units_per_device_pixel_at_unit_full_zoom(&self) -> i32 {\n match self.pres_context() {\n Some(pc) => unsafe { (*pc.mDeviceContext.mRawPtr).mAppUnitsPerDevPixelAtUnitFullZoom },\n None => AU_PER_PX,\n }\n }\n\n /// Returns the device pixel ratio, ignoring the full zoom factor.\n pub fn device_pixel_ratio_ignoring_full_zoom(&self) -> Scale {\n let au_per_px = AU_PER_PX as f32;\n Scale::new(au_per_px / self.app_units_per_device_pixel_at_unit_full_zoom() as f32)\n }\n\n /// Returns the device pixel ratio.\n pub fn device_pixel_ratio(&self) -> Scale {\n let pc = match self.pres_context() {\n Some(pc) => pc,\n None => return Scale::new(1.),\n };\n\n if pc.mMediaEmulationData.mDPPX > 0.0 {\n return Scale::new(pc.mMediaEmulationData.mDPPX);\n }\n\n let au_per_dpx = pc.mCurAppUnitsPerDevPixel as f32;\n let au_per_px = AU_PER_PX as f32;\n Scale::new(au_per_px / au_per_dpx)\n }\n\n /// Returns whether document colors are enabled.\n #[inline]\n pub fn forced_colors(&self) -> ForcedColors {\n self.pres_context()\n .map_or(ForcedColors::None, |pc| pc.mForcedColors)\n }\n\n /// Computes a system color and returns it as an nscolor.\n pub(crate) fn system_nscolor(\n &self,\n system_color: SystemColor,\n color_scheme: ColorSchemeFlags,\n ) -> u32 {\n unsafe { bindings::Gecko_ComputeSystemColor(system_color, self.document(), &color_scheme) }\n }\n\n /// Returns whether the used color-scheme for `color-scheme` should be dark.\n pub(crate) fn is_dark_color_scheme(&self, color_scheme: ColorSchemeFlags) -> bool {\n unsafe { bindings::Gecko_IsDarkColorScheme(self.document(), &color_scheme) }\n }\n\n /// Returns the default background color.\n ///\n /// This is only for forced-colors/high-contrast, so looking at light colors\n /// is ok.\n pub fn default_background_color(&self) -> AbsoluteColor {\n AbsoluteColor::from_nscolor(\n self.system_nscolor(SystemColor::Canvas, ColorScheme::normal().bits),\n )\n }\n\n /// Returns the default foreground color.\n ///\n /// See above for looking at light colors only.\n pub fn default_color(&self) -> AbsoluteColor {\n AbsoluteColor::from_nscolor(\n self.system_nscolor(SystemColor::Canvastext, ColorScheme::normal().bits),\n )\n }\n\n /// Returns the current effective text zoom.\n #[inline]\n fn text_zoom(&self) -> f32 {\n let pc = match self.pres_context() {\n Some(pc) => pc,\n None => return 1.,\n };\n pc.mTextZoom\n }\n\n /// Applies text zoom to a font-size or line-height value (see nsStyleFont::ZoomText).\n #[inline]\n pub fn zoom_text(&self, size: Length) -> Length {\n size.scale_by(self.text_zoom())\n }\n\n /// Un-apply text zoom.\n #[inline]\n pub fn unzoom_text(&self, size: Length) -> Length {\n size.scale_by(1. / self.text_zoom())\n }\n\n /// Returns safe area insets\n pub fn safe_area_insets(&self) -> SideOffsets2D {\n let pc = match self.pres_context() {\n Some(pc) => pc,\n None => return SideOffsets2D::zero(),\n };\n let mut top = 0.0;\n let mut right = 0.0;\n let mut bottom = 0.0;\n let mut left = 0.0;\n unsafe {\n bindings::Gecko_GetSafeAreaInsets(pc, &mut top, &mut right, &mut bottom, &mut left)\n };\n SideOffsets2D::new(top, right, bottom, left)\n }\n\n /// Returns true if the given MIME type is supported\n pub fn is_supported_mime_type(&self, mime_type: &str) -> bool {\n unsafe {\n bindings::Gecko_IsSupportedImageMimeType(mime_type.as_ptr(), mime_type.len() as u32)\n }\n }\n\n /// Return whether the document is a chrome document.\n ///\n /// This check is consistent with how we enable chrome rules for chrome:// and resource://\n /// stylesheets (and thus chrome:// documents).\n #[inline]\n pub fn chrome_rules_enabled_for_document(&self) -> bool {\n self.document().mChromeRulesEnabled()\n }\n}\n\nimpl fmt::Debug for Device {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n use nsstring::nsCString;\n\n let mut doc_uri = nsCString::new();\n unsafe {\n bindings::Gecko_nsIURI_Debug((*self.document()).mDocumentURI.raw(), &mut doc_uri)\n };\n\n f.debug_struct(\"Device\")\n .field(\"document_url\", &doc_uri)\n .finish()\n }\n}\n" }, { "path": "style/device/mod.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! Media-query device and expression representation.\n\nuse crate::color::AbsoluteColor;\nuse crate::custom_properties::CssEnvironment;\n#[cfg(feature = \"servo\")]\nuse crate::derives::*;\nuse crate::properties::ComputedValues;\nuse crate::values::computed::font::QueryFontMetricsFlags;\nuse crate::values::computed::Length;\nuse parking_lot::RwLock;\nuse servo_arc::Arc;\nuse std::mem;\nuse std::sync::atomic::{AtomicBool, AtomicU32, Ordering};\n\n#[cfg(feature = \"gecko\")]\nuse crate::device::gecko::ExtraDeviceData;\n#[cfg(feature = \"servo\")]\nuse crate::device::servo::ExtraDeviceData;\n\n#[cfg(feature = \"gecko\")]\npub mod gecko;\n#[cfg(feature = \"servo\")]\npub mod servo;\n\n/// A device is a structure that represents the current media a given document\n/// is displayed in.\n///\n/// This is the struct against which media queries are evaluated, has a default\n/// values computed, and contains all the viewport rule state.\n///\n/// This structure also contains atomics used for computing root font-relative\n/// units. These atomics use relaxed ordering, since when computing the style\n/// of the root element, there can't be any other style being computed at the\n/// same time (given we need the style of the parent to compute everything else).\n///\n/// In Gecko, it wraps a pres context.\n#[cfg_attr(feature = \"servo\", derive(Debug, MallocSizeOf))]\npub struct Device {\n /// The default computed values for this Device.\n #[cfg_attr(feature = \"servo\", ignore_malloc_size_of = \"Arc is shared\")]\n default_values: Arc,\n /// Current computed style of the root element, used for calculations of\n /// root font-relative units.\n #[cfg_attr(feature = \"servo\", ignore_malloc_size_of = \"Arc\")]\n root_style: RwLock>,\n /// Font size of the root element, used for rem units in other elements.\n root_font_size: AtomicU32,\n /// Line height of the root element, used for rlh units in other elements.\n root_line_height: AtomicU32,\n /// X-height of the root element, used for rex units in other elements.\n root_font_metrics_ex: AtomicU32,\n /// Cap-height of the root element, used for rcap units in other elements.\n root_font_metrics_cap: AtomicU32,\n /// Advance measure (ch) of the root element, used for rch units in other elements.\n root_font_metrics_ch: AtomicU32,\n /// Ideographic advance measure of the root element, used for ric units in other elements.\n root_font_metrics_ic: AtomicU32,\n /// Whether any styles computed in the document relied on the root font-size\n /// by using rem units.\n used_root_font_size: AtomicBool,\n /// Whether any styles computed in the document relied on the root line-height\n /// by using rlh units.\n used_root_line_height: AtomicBool,\n /// Whether any styles computed in the document relied on the root font metrics\n /// by using rcap, rch, rex, or ric units. This is a lock instead of an atomic\n /// in order to prevent concurrent writes to the root font metric values.\n #[cfg_attr(feature = \"servo\", ignore_malloc_size_of = \"Pure stack type\")]\n used_root_font_metrics: RwLock,\n /// Whether any styles computed in the document relied on font metrics.\n used_font_metrics: AtomicBool,\n /// Whether any styles computed in the document relied on the viewport size\n /// by using vw/vh/vmin/vmax units.\n used_viewport_size: AtomicBool,\n /// Whether any styles computed in the document relied on the viewport size\n /// by using dvw/dvh/dvmin/dvmax units.\n used_dynamic_viewport_size: AtomicBool,\n /// The CssEnvironment object responsible of getting CSS environment\n /// variables.\n environment: CssEnvironment,\n /// The body text color, stored as an `nscolor`, used for the \"tables\n /// inherit from body\" quirk.\n ///\n /// \n body_text_color: AtomicU32,\n\n /// Extra Gecko-specific or Servo-specific data.\n extra: ExtraDeviceData,\n}\n\nimpl Device {\n /// Get the relevant environment to resolve `env()` functions.\n #[inline]\n pub fn environment(&self) -> &CssEnvironment {\n &self.environment\n }\n\n /// Returns the default computed values as a reference, in order to match\n /// Servo.\n pub fn default_computed_values(&self) -> &ComputedValues {\n &self.default_values\n }\n\n /// Returns the default computed values as an `Arc`.\n pub fn default_computed_values_arc(&self) -> &Arc {\n &self.default_values\n }\n\n /// Store a pointer to the root element's computed style, for use in\n /// calculation of root font-relative metrics.\n pub fn set_root_style(&self, style: &Arc) {\n *self.root_style.write() = style.clone();\n }\n\n /// Get the font size of the root element (for rem)\n pub fn root_font_size(&self) -> Length {\n self.used_root_font_size.store(true, Ordering::Relaxed);\n Length::new(f32::from_bits(self.root_font_size.load(Ordering::Relaxed)))\n }\n\n /// Set the font size of the root element (for rem), in zoom-independent CSS pixels.\n pub fn set_root_font_size(&self, size: f32) {\n self.root_font_size.store(size.to_bits(), Ordering::Relaxed)\n }\n\n /// Get the line height of the root element (for rlh)\n pub fn root_line_height(&self) -> Length {\n self.used_root_line_height.store(true, Ordering::Relaxed);\n Length::new(f32::from_bits(\n self.root_line_height.load(Ordering::Relaxed),\n ))\n }\n\n /// Set the line height of the root element (for rlh), in zoom-independent CSS pixels.\n pub fn set_root_line_height(&self, size: f32) {\n self.root_line_height\n .store(size.to_bits(), Ordering::Relaxed);\n }\n\n /// Get the x-height of the root element (for rex)\n pub fn root_font_metrics_ex(&self) -> Length {\n self.ensure_root_font_metrics_updated();\n Length::new(f32::from_bits(\n self.root_font_metrics_ex.load(Ordering::Relaxed),\n ))\n }\n\n /// Set the x-height of the root element (for rex), in zoom-independent CSS pixels.\n pub fn set_root_font_metrics_ex(&self, size: f32) -> bool {\n let size = size.to_bits();\n let previous = self.root_font_metrics_ex.swap(size, Ordering::Relaxed);\n previous != size\n }\n\n /// Get the cap-height of the root element (for rcap)\n pub fn root_font_metrics_cap(&self) -> Length {\n self.ensure_root_font_metrics_updated();\n Length::new(f32::from_bits(\n self.root_font_metrics_cap.load(Ordering::Relaxed),\n ))\n }\n\n /// Set the cap-height of the root element (for rcap), in zoom-independent CSS pixels.\n pub fn set_root_font_metrics_cap(&self, size: f32) -> bool {\n let size = size.to_bits();\n let previous = self.root_font_metrics_cap.swap(size, Ordering::Relaxed);\n previous != size\n }\n\n /// Get the advance measure of the root element (for rch)\n pub fn root_font_metrics_ch(&self) -> Length {\n self.ensure_root_font_metrics_updated();\n Length::new(f32::from_bits(\n self.root_font_metrics_ch.load(Ordering::Relaxed),\n ))\n }\n\n /// Set the advance measure of the root element (for rch), in zoom-independent CSS pixels.\n pub fn set_root_font_metrics_ch(&self, size: f32) -> bool {\n let size = size.to_bits();\n let previous = self.root_font_metrics_ch.swap(size, Ordering::Relaxed);\n previous != size\n }\n\n /// Get the ideographic advance measure of the root element (for ric)\n pub fn root_font_metrics_ic(&self) -> Length {\n self.ensure_root_font_metrics_updated();\n Length::new(f32::from_bits(\n self.root_font_metrics_ic.load(Ordering::Relaxed),\n ))\n }\n\n /// Set the ideographic advance measure of the root element (for ric), in zoom-independent CSS pixels.\n pub fn set_root_font_metrics_ic(&self, size: f32) -> bool {\n let size = size.to_bits();\n let previous = self.root_font_metrics_ic.swap(size, Ordering::Relaxed);\n previous != size\n }\n\n fn ensure_root_font_metrics_updated(&self) {\n let mut guard = self.used_root_font_metrics.write();\n let previously_computed = mem::replace(&mut *guard, true);\n if !previously_computed {\n self.update_root_font_metrics();\n }\n }\n\n /// Compute the root element's font metrics, and returns a bool indicating whether\n /// the font metrics have changed since the previous restyle.\n pub fn update_root_font_metrics(&self) -> bool {\n let root_style = self.root_style.read();\n let root_effective_zoom = (*root_style).effective_zoom;\n let root_font_size = (*root_style).get_font().clone_font_size().computed_size();\n\n let root_font_metrics = self.query_font_metrics(\n (*root_style).writing_mode.is_upright(),\n &(*root_style).get_font(),\n root_font_size,\n QueryFontMetricsFlags::USE_USER_FONT_SET\n | QueryFontMetricsFlags::NEEDS_CH\n | QueryFontMetricsFlags::NEEDS_IC,\n /* track_usage = */ false,\n );\n\n let mut root_font_metrics_changed = false;\n root_font_metrics_changed |= self.set_root_font_metrics_ex(\n root_effective_zoom.unzoom(root_font_metrics.x_height_or_default(root_font_size).px()),\n );\n root_font_metrics_changed |= self.set_root_font_metrics_ch(\n root_effective_zoom.unzoom(\n root_font_metrics\n .zero_advance_measure_or_default(\n root_font_size,\n (*root_style).writing_mode.is_upright(),\n )\n .px(),\n ),\n );\n root_font_metrics_changed |= self.set_root_font_metrics_cap(\n root_effective_zoom.unzoom(root_font_metrics.cap_height_or_default().px()),\n );\n root_font_metrics_changed |= self.set_root_font_metrics_ic(\n root_effective_zoom.unzoom(root_font_metrics.ic_width_or_default(root_font_size).px()),\n );\n\n root_font_metrics_changed\n }\n\n /// Returns whether we ever looked up the root font size of the Device.\n pub fn used_root_font_size(&self) -> bool {\n self.used_root_font_size.load(Ordering::Relaxed)\n }\n\n /// Returns whether we ever looked up the root line-height of the device.\n pub fn used_root_line_height(&self) -> bool {\n self.used_root_line_height.load(Ordering::Relaxed)\n }\n\n /// Returns whether we ever looked up the root font metrics of the device.\n pub fn used_root_font_metrics(&self) -> bool {\n *self.used_root_font_metrics.read()\n }\n\n /// Returns whether we ever looked up the viewport size of the Device.\n pub fn used_viewport_size(&self) -> bool {\n self.used_viewport_size.load(Ordering::Relaxed)\n }\n\n /// Returns whether we ever looked up the dynamic viewport size of the Device.\n pub fn used_dynamic_viewport_size(&self) -> bool {\n self.used_dynamic_viewport_size.load(Ordering::Relaxed)\n }\n\n /// Returns whether font metrics have been queried.\n pub fn used_font_metrics(&self) -> bool {\n self.used_font_metrics.load(Ordering::Relaxed)\n }\n\n /// Returns the body text color.\n pub fn body_text_color(&self) -> AbsoluteColor {\n AbsoluteColor::from_nscolor(self.body_text_color.load(Ordering::Relaxed))\n }\n\n /// Sets the body text color for the \"inherit color from body\" quirk.\n ///\n /// \n pub fn set_body_text_color(&self, color: AbsoluteColor) {\n self.body_text_color\n .store(color.to_nscolor(), Ordering::Relaxed)\n }\n}\n" }, { "path": "style/device/servo.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! Servo-specific logic for [`Device`].\n\nuse crate::color::AbsoluteColor;\nuse crate::context::QuirksMode;\nuse crate::custom_properties::CssEnvironment;\nuse crate::font_metrics::FontMetrics;\nuse crate::logical_geometry::WritingMode;\nuse crate::media_queries::MediaType;\nuse crate::properties::style_structs::Font;\nuse crate::properties::ComputedValues;\nuse crate::queries::values::PrefersColorScheme;\nuse crate::values::computed::font::GenericFontFamily;\nuse crate::values::computed::{CSSPixelLength, Length, LineHeight, NonNegativeLength};\nuse crate::values::specified::color::{ColorSchemeFlags, ForcedColors, SystemColor};\nuse crate::values::specified::font::{\n QueryFontMetricsFlags, FONT_MEDIUM_CAP_PX, FONT_MEDIUM_CH_PX, FONT_MEDIUM_EX_PX,\n FONT_MEDIUM_IC_PX, FONT_MEDIUM_LINE_HEIGHT_PX, FONT_MEDIUM_PX,\n};\nuse crate::values::specified::ViewportVariant;\nuse crate::values::KeyframesName;\nuse app_units::{Au, AU_PER_PX};\nuse euclid::default::Size2D as UntypedSize2D;\nuse euclid::{Scale, SideOffsets2D, Size2D};\nuse malloc_size_of_derive::MallocSizeOf;\nuse mime::Mime;\nuse parking_lot::RwLock;\nuse servo_arc::Arc;\nuse std::fmt::Debug;\nuse std::sync::atomic::{AtomicBool, AtomicU32, Ordering};\nuse style_traits::{CSSPixel, DevicePixel};\n\nuse crate::device::Device;\n\n/// A trait used to query font metrics in clients of Stylo. This is used by Device to\n/// query font metrics in a way that is specific to the client using Stylo.\npub trait FontMetricsProvider: Debug + Sync {\n /// Query the font metrics for the given font and the given base font size.\n fn query_font_metrics(\n &self,\n vertical: bool,\n font: &Font,\n base_size: CSSPixelLength,\n flags: QueryFontMetricsFlags,\n ) -> FontMetrics;\n /// Gets the base size given a generic font family.\n fn base_size_for_generic(&self, generic: GenericFontFamily) -> Length;\n}\n\n#[derive(Debug, MallocSizeOf)]\npub(super) struct ExtraDeviceData {\n /// The current media type used by de device.\n media_type: MediaType,\n /// The current viewport size, in CSS pixels.\n viewport_size: Size2D,\n /// The current device pixel ratio, from CSS pixels to device pixels.\n device_pixel_ratio: Scale,\n /// The current quirks mode.\n #[ignore_malloc_size_of = \"Pure stack type\"]\n quirks_mode: QuirksMode,\n /// Whether the user prefers light mode or dark mode\n #[ignore_malloc_size_of = \"Pure stack type\"]\n prefers_color_scheme: PrefersColorScheme,\n /// An implementation of a trait which implements support for querying font metrics.\n #[ignore_malloc_size_of = \"Owned by embedder\"]\n font_metrics_provider: Box,\n}\n\nimpl Device {\n /// Trivially construct a new `Device`.\n pub fn new(\n media_type: MediaType,\n quirks_mode: QuirksMode,\n viewport_size: Size2D,\n device_pixel_ratio: Scale,\n font_metrics_provider: Box,\n default_values: Arc,\n prefers_color_scheme: PrefersColorScheme,\n ) -> Device {\n let root_style = RwLock::new(Arc::clone(&default_values));\n Device {\n root_style,\n root_font_size: AtomicU32::new(FONT_MEDIUM_PX.to_bits()),\n root_line_height: AtomicU32::new(FONT_MEDIUM_LINE_HEIGHT_PX.to_bits()),\n root_font_metrics_ex: AtomicU32::new(FONT_MEDIUM_EX_PX.to_bits()),\n root_font_metrics_cap: AtomicU32::new(FONT_MEDIUM_CAP_PX.to_bits()),\n root_font_metrics_ch: AtomicU32::new(FONT_MEDIUM_CH_PX.to_bits()),\n root_font_metrics_ic: AtomicU32::new(FONT_MEDIUM_IC_PX.to_bits()),\n used_root_font_size: AtomicBool::new(false),\n used_root_line_height: AtomicBool::new(false),\n used_root_font_metrics: RwLock::new(false),\n used_font_metrics: AtomicBool::new(false),\n used_viewport_size: AtomicBool::new(false),\n used_dynamic_viewport_size: AtomicBool::new(false),\n environment: CssEnvironment,\n default_values,\n body_text_color: AtomicU32::new(AbsoluteColor::BLACK.to_nscolor()),\n extra: ExtraDeviceData {\n media_type,\n viewport_size,\n device_pixel_ratio,\n quirks_mode,\n prefers_color_scheme,\n font_metrics_provider,\n },\n }\n }\n\n /// Returns the computed line-height for the font in a given computed values instance.\n ///\n /// If you pass down an element, then the used line-height is returned.\n pub fn calc_line_height(\n &self,\n font: &crate::properties::style_structs::Font,\n _writing_mode: WritingMode,\n _element: Option<()>,\n ) -> NonNegativeLength {\n (match font.line_height {\n // TODO: compute `normal` from the font metrics\n LineHeight::Normal => CSSPixelLength::new(0.),\n LineHeight::Number(number) => font.font_size.computed_size() * number.0,\n LineHeight::Length(length) => length.0,\n })\n .into()\n }\n\n /// Get the quirks mode of the current device.\n pub fn quirks_mode(&self) -> QuirksMode {\n self.extra.quirks_mode\n }\n\n /// Gets the base size given a generic font family.\n pub fn base_size_for_generic(&self, generic: GenericFontFamily) -> Length {\n self.extra\n .font_metrics_provider\n .base_size_for_generic(generic)\n }\n\n /// Whether a given animation name may be referenced from style.\n pub fn animation_name_may_be_referenced(&self, _: &KeyframesName) -> bool {\n // Assume it is, since we don't have any good way to prove it's not.\n true\n }\n\n /// Get the viewport size on this [`Device`].\n pub fn viewport_size(&self) -> Size2D {\n self.extra.viewport_size\n }\n\n /// Set the viewport size on this [`Device`].\n ///\n /// Note that this does not update any associated `Stylist`. For this you must call\n /// `Stylist::media_features_change_changed_style` and\n /// `Stylist::force_stylesheet_origins_dirty`.\n pub fn set_viewport_size(&mut self, viewport_size: Size2D) {\n self.extra.viewport_size = viewport_size;\n }\n\n /// Returns the viewport size of the current device in app units, needed,\n /// among other things, to resolve viewport units.\n #[inline]\n pub fn au_viewport_size(&self) -> UntypedSize2D {\n Size2D::new(\n Au::from_f32_px(self.extra.viewport_size.width),\n Au::from_f32_px(self.extra.viewport_size.height),\n )\n }\n\n /// Like the above, but records that we've used viewport units.\n pub fn au_viewport_size_for_viewport_unit_resolution(\n &self,\n _: ViewportVariant,\n ) -> UntypedSize2D {\n self.used_viewport_size.store(true, Ordering::Relaxed);\n // Servo doesn't have dynamic UA interfaces that affect the viewport,\n // so we can just ignore the ViewportVariant.\n self.au_viewport_size()\n }\n\n /// Returns the number of app units per device pixel we're using currently.\n pub fn app_units_per_device_pixel(&self) -> i32 {\n (AU_PER_PX as f32 / self.extra.device_pixel_ratio.0) as i32\n }\n\n /// Returns the device pixel ratio, ignoring the full zoom factor.\n pub fn device_pixel_ratio_ignoring_full_zoom(&self) -> Scale {\n self.extra.device_pixel_ratio\n }\n\n /// Returns the device pixel ratio.\n pub fn device_pixel_ratio(&self) -> Scale {\n self.extra.device_pixel_ratio\n }\n\n /// Set a new device pixel ratio on this [`Device`].\n ///\n /// Note that this does not update any associated `Stylist`. For this you must call\n /// `Stylist::media_features_change_changed_style` and\n /// `Stylist::force_stylesheet_origins_dirty`.\n pub fn set_device_pixel_ratio(\n &mut self,\n device_pixel_ratio: Scale,\n ) {\n self.extra.device_pixel_ratio = device_pixel_ratio;\n }\n\n /// Gets the size of the scrollbar in CSS pixels.\n pub fn scrollbar_inline_size(&self) -> CSSPixelLength {\n // TODO: implement this.\n CSSPixelLength::new(0.0)\n }\n\n /// Queries font metrics using the [`FontMetricsProvider`] interface.\n pub fn query_font_metrics(\n &self,\n vertical: bool,\n font: &Font,\n base_size: CSSPixelLength,\n flags: QueryFontMetricsFlags,\n track_usage: bool,\n ) -> FontMetrics {\n if track_usage {\n self.used_font_metrics.store(true, Ordering::Relaxed);\n }\n self.extra\n .font_metrics_provider\n .query_font_metrics(vertical, font, base_size, flags)\n }\n\n /// Return the media type of the current device.\n pub fn media_type(&self) -> MediaType {\n self.extra.media_type.clone()\n }\n\n /// Returns whether document colors are enabled.\n pub fn forced_colors(&self) -> ForcedColors {\n ForcedColors::None\n }\n\n /// Returns the default background color.\n pub fn default_background_color(&self) -> AbsoluteColor {\n AbsoluteColor::WHITE\n }\n\n /// Returns the default foreground color.\n pub fn default_color(&self) -> AbsoluteColor {\n AbsoluteColor::BLACK\n }\n\n /// Set the [`PrefersColorScheme`] value on this [`Device`].\n ///\n /// Note that this does not update any associated `Stylist`. For this you must call\n /// `Stylist::media_features_change_changed_style` and\n /// `Stylist::force_stylesheet_origins_dirty`.\n pub fn set_color_scheme(&mut self, new_color_scheme: PrefersColorScheme) {\n self.extra.prefers_color_scheme = new_color_scheme;\n }\n\n /// Returns the color scheme of this [`Device`].\n pub fn color_scheme(&self) -> PrefersColorScheme {\n self.extra.prefers_color_scheme\n }\n\n pub(crate) fn is_dark_color_scheme(&self, _: ColorSchemeFlags) -> bool {\n false\n }\n\n pub(crate) fn system_color(\n &self,\n system_color: SystemColor,\n color_scheme_flags: ColorSchemeFlags,\n ) -> AbsoluteColor {\n fn srgb(r: u8, g: u8, b: u8) -> AbsoluteColor {\n AbsoluteColor::srgb_legacy(r, g, b, 1f32)\n }\n\n // Refer to spec\n // \n if self.is_dark_color_scheme(color_scheme_flags) {\n // Note: is_dark_color_scheme always returns true, so this code is dead code.\n match system_color {\n SystemColor::Accentcolor => srgb(10, 132, 255),\n SystemColor::Accentcolortext => srgb(255, 255, 255),\n SystemColor::Activetext => srgb(255, 0, 0),\n SystemColor::Linktext => srgb(158, 158, 255),\n SystemColor::Visitedtext => srgb(208, 173, 240),\n SystemColor::Buttonborder\n // Deprecated system colors (CSS Color 4) mapped to Buttonborder.\n | SystemColor::Activeborder\n | SystemColor::Inactiveborder\n | SystemColor::Threeddarkshadow\n | SystemColor::Threedshadow\n | SystemColor::Windowframe => srgb(255, 255, 255),\n SystemColor::Buttonface\n // Deprecated system colors (CSS Color 4) mapped to Buttonface.\n | SystemColor::Buttonhighlight\n | SystemColor::Buttonshadow\n | SystemColor::Threedface\n | SystemColor::Threedhighlight\n | SystemColor::Threedlightshadow => srgb(107, 107, 107),\n SystemColor::Buttontext => srgb(245, 245, 245),\n SystemColor::Canvas\n // Deprecated system colors (CSS Color 4) mapped to Canvas.\n | SystemColor::Activecaption\n | SystemColor::Appworkspace\n | SystemColor::Background\n | SystemColor::Inactivecaption\n | SystemColor::Infobackground\n | SystemColor::Menu\n | SystemColor::Scrollbar\n | SystemColor::Window => srgb(30, 30, 30),\n SystemColor::Canvastext\n // Deprecated system colors (CSS Color 4) mapped to Canvastext.\n | SystemColor::Captiontext\n | SystemColor::Infotext\n | SystemColor::Menutext\n | SystemColor::Windowtext => srgb(232, 232, 232),\n SystemColor::Field => srgb(45, 45, 45),\n SystemColor::Fieldtext => srgb(240, 240, 240),\n SystemColor::Graytext\n // Deprecated system colors (CSS Color 4) mapped to Graytext.\n | SystemColor::Inactivecaptiontext => srgb(155, 155, 155),\n SystemColor::Highlight => srgb(38, 79, 120),\n SystemColor::Highlighttext => srgb(255, 255, 255),\n SystemColor::Mark => srgb(102, 92, 0),\n SystemColor::Marktext => srgb(255, 255, 255),\n SystemColor::Selecteditem => srgb(153, 200, 255),\n SystemColor::Selecteditemtext => srgb(59, 59, 59),\n }\n } else {\n match system_color {\n SystemColor::Accentcolor => srgb(0, 102, 204),\n SystemColor::Accentcolortext => srgb(255, 255, 255),\n SystemColor::Activetext => srgb(238, 0, 0),\n SystemColor::Linktext => srgb(0, 0, 238),\n SystemColor::Visitedtext => srgb(85, 26, 139),\n SystemColor::Buttonborder\n // Deprecated system colors (CSS Color 4) mapped to Buttonborder.\n | SystemColor::Activeborder\n | SystemColor::Inactiveborder\n | SystemColor::Threeddarkshadow\n | SystemColor::Threedshadow\n | SystemColor::Windowframe => srgb(169, 169, 169),\n SystemColor::Buttonface\n // Deprecated system colors (CSS Color 4) mapped to Buttonface.\n | SystemColor::Buttonhighlight\n | SystemColor::Buttonshadow\n | SystemColor::Threedface\n | SystemColor::Threedhighlight\n | SystemColor::Threedlightshadow => srgb(220, 220, 220),\n SystemColor::Buttontext => srgb(0, 0, 0),\n SystemColor::Canvas\n // Deprecated system colors (CSS Color 4) mapped to Canvas.\n | SystemColor::Activecaption\n | SystemColor::Appworkspace\n | SystemColor::Background\n | SystemColor::Inactivecaption\n | SystemColor::Infobackground\n | SystemColor::Menu\n | SystemColor::Scrollbar\n | SystemColor::Window => srgb(255, 255, 255),\n SystemColor::Canvastext\n // Deprecated system colors (CSS Color 4) mapped to Canvastext.\n | SystemColor::Captiontext\n | SystemColor::Infotext\n | SystemColor::Menutext\n | SystemColor::Windowtext => srgb(0, 0, 0),\n SystemColor::Field => srgb(255, 255, 255),\n SystemColor::Fieldtext => srgb(0, 0, 0),\n SystemColor::Graytext\n // Deprecated system colors (CSS Color 4) mapped to Graytext.\n | SystemColor::Inactivecaptiontext => srgb(109, 109, 109),\n SystemColor::Highlight => srgb(0, 65, 198),\n SystemColor::Highlighttext => srgb(0, 0, 0),\n SystemColor::Mark => srgb(255, 235, 59),\n SystemColor::Marktext => srgb(0, 0, 0),\n SystemColor::Selecteditem => srgb(0, 102, 204),\n SystemColor::Selecteditemtext => srgb(255, 255, 255),\n }\n }\n }\n\n /// Returns safe area insets\n pub fn safe_area_insets(&self) -> SideOffsets2D {\n SideOffsets2D::zero()\n }\n\n /// Returns true if the given MIME type is supported\n pub fn is_supported_mime_type(&self, mime_type: &str) -> bool {\n match mime_type.parse::() {\n Ok(m) => {\n // Keep this in sync with 'image_classifer' from\n // components/net/mime_classifier.rs\n m == mime::IMAGE_BMP\n || m == mime::IMAGE_GIF\n || m == mime::IMAGE_PNG\n || m == mime::IMAGE_JPEG\n || m == \"image/x-icon\"\n || m == \"image/webp\"\n },\n _ => false,\n }\n }\n\n /// Return whether the document is a chrome document.\n #[inline]\n pub fn chrome_rules_enabled_for_document(&self) -> bool {\n false\n }\n}\n" }, { "path": "style/dom.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! Types and traits used to access the DOM from style calculation.\n\n#![allow(unsafe_code)]\n#![deny(missing_docs)]\n\nuse crate::applicable_declarations::ApplicableDeclarationBlock;\nuse crate::context::SharedStyleContext;\n#[cfg(feature = \"gecko\")]\nuse crate::context::UpdateAnimationsTasks;\nuse crate::data::{ElementData, ElementDataMut, ElementDataRef};\nuse crate::device::Device;\nuse crate::properties::{AnimationDeclarations, ComputedValues, PropertyDeclarationBlock};\nuse crate::selector_map::PrecomputedHashMap;\nuse crate::selector_parser::{AttrValue, Lang, PseudoElement, RestyleDamage, SelectorImpl};\nuse crate::shared_lock::{Locked, SharedRwLock};\nuse crate::stylesheets::scope_rule::ImplicitScopeRoot;\nuse crate::stylist::CascadeData;\nuse crate::values::computed::Display;\nuse crate::values::AtomIdent;\nuse crate::{LocalName, Namespace, WeakAtom};\nuse dom::ElementState;\nuse selectors::matching::{ElementSelectorFlags, QuirksMode, VisitedHandlingMode};\nuse selectors::sink::Push;\nuse selectors::{Element as SelectorsElement, OpaqueElement};\nuse servo_arc::{Arc, ArcBorrow};\nuse smallvec::SmallVec;\nuse std::fmt;\nuse std::fmt::Debug;\nuse std::hash::Hash;\nuse std::ops::Deref;\n\npub use style_traits::dom::OpaqueNode;\n\n/// Simple trait to provide basic information about the type of an element.\n///\n/// We avoid exposing the full type id, since computing it in the general case\n/// would be difficult for Gecko nodes.\npub trait NodeInfo {\n /// Whether this node is an element.\n fn is_element(&self) -> bool;\n /// Whether this node is a text node.\n fn is_text_node(&self) -> bool;\n}\n\n/// A node iterator that only returns node that don't need layout.\npub struct LayoutIterator(pub T);\n\nimpl Iterator for LayoutIterator\nwhere\n T: Iterator,\n N: NodeInfo,\n{\n type Item = N;\n\n fn next(&mut self) -> Option {\n loop {\n let n = self.0.next()?;\n // Filter out nodes that layout should ignore.\n if n.is_text_node() || n.is_element() {\n return Some(n);\n }\n }\n }\n}\n\n/// An iterator over the DOM children of a node.\npub struct DomChildren(Option);\nimpl Iterator for DomChildren\nwhere\n N: TNode,\n{\n type Item = N;\n\n fn next(&mut self) -> Option {\n let n = self.0.take()?;\n self.0 = n.next_sibling();\n Some(n)\n }\n}\n\n/// An iterator over the DOM descendants of a node in pre-order.\npub struct DomDescendants {\n previous: Option,\n scope: N,\n}\n\nimpl DomDescendants\nwhere\n N: TNode,\n{\n /// Returns the next element ignoring all of our subtree.\n #[inline]\n pub fn next_skipping_children(&mut self) -> Option {\n let prev = self.previous.take()?;\n self.previous = prev.next_in_preorder_skipping_children(self.scope);\n self.previous\n }\n}\n\nimpl Iterator for DomDescendants\nwhere\n N: TNode,\n{\n type Item = N;\n\n #[inline]\n fn next(&mut self) -> Option {\n let prev = self.previous.take()?;\n self.previous = prev.next_in_preorder(self.scope);\n self.previous\n }\n}\n\n/// The `TDocument` trait, to represent a document node.\npub trait TDocument: Sized + Copy + Clone {\n /// The concrete `TNode` type.\n type ConcreteNode: TNode;\n\n /// Get this document as a `TNode`.\n fn as_node(&self) -> Self::ConcreteNode;\n\n /// Returns whether this document is an HTML document.\n fn is_html_document(&self) -> bool;\n\n /// Returns the quirks mode of this document.\n fn quirks_mode(&self) -> QuirksMode;\n\n /// Get a list of elements with a given ID in this document, sorted by\n /// tree position.\n ///\n /// Can return an error to signal that this list is not available, or also\n /// return an empty slice.\n fn elements_with_id<'a>(\n &self,\n _id: &AtomIdent,\n ) -> Result<&'a [::ConcreteElement], ()>\n where\n Self: 'a,\n {\n Err(())\n }\n\n /// This document's shared lock.\n fn shared_lock(&self) -> &SharedRwLock;\n}\n\n/// The `TNode` trait. This is the main generic trait over which the style\n/// system can be implemented.\npub trait TNode: Sized + Copy + Clone + Debug + NodeInfo + PartialEq {\n /// The concrete `TElement` type.\n type ConcreteElement: TElement;\n\n /// The concrete `TDocument` type.\n type ConcreteDocument: TDocument;\n\n /// The concrete `TShadowRoot` type.\n type ConcreteShadowRoot: TShadowRoot;\n\n /// Get this node's parent node.\n fn parent_node(&self) -> Option;\n\n /// Get this node's first child.\n fn first_child(&self) -> Option;\n\n /// Get this node's last child.\n fn last_child(&self) -> Option;\n\n /// Get this node's previous sibling.\n fn prev_sibling(&self) -> Option;\n\n /// Get this node's next sibling.\n fn next_sibling(&self) -> Option;\n\n /// Get the owner document of this node.\n fn owner_doc(&self) -> Self::ConcreteDocument;\n\n /// Iterate over the DOM children of a node.\n #[inline(always)]\n fn dom_children(&self) -> DomChildren {\n DomChildren(self.first_child())\n }\n\n /// Returns whether the node is attached to a document.\n fn is_in_document(&self) -> bool;\n\n /// Iterate over the DOM children of a node, in preorder.\n #[inline(always)]\n fn dom_descendants(&self) -> DomDescendants {\n DomDescendants {\n previous: Some(*self),\n scope: *self,\n }\n }\n\n /// Returns the next node after this one, in a pre-order tree-traversal of\n /// the subtree rooted at scoped_to.\n #[inline]\n fn next_in_preorder(&self, scoped_to: Self) -> Option {\n if let Some(c) = self.first_child() {\n return Some(c);\n }\n self.next_in_preorder_skipping_children(scoped_to)\n }\n\n /// Returns the next node in tree order, skipping the children of the current node.\n ///\n /// This is useful when we know that a subtree cannot contain matches, allowing us\n /// to skip entire subtrees during traversal.\n #[inline]\n fn next_in_preorder_skipping_children(&self, scoped_to: Self) -> Option {\n let mut current = *self;\n loop {\n if current == scoped_to {\n return None;\n }\n\n if let Some(s) = current.next_sibling() {\n return Some(s);\n }\n\n debug_assert!(\n current.parent_node().is_some(),\n \"Not a descendant of the scope?\"\n );\n current = current.parent_node()?;\n }\n }\n\n /// Returns the depth of this node in the DOM.\n fn depth(&self) -> usize {\n let mut depth = 0;\n let mut curr = *self;\n while let Some(parent) = curr.traversal_parent() {\n depth += 1;\n curr = parent.as_node();\n }\n depth\n }\n\n /// Get this node's parent element from the perspective of a restyle\n /// traversal.\n fn traversal_parent(&self) -> Option;\n\n /// Get this node's parent element if present.\n fn parent_element(&self) -> Option {\n self.parent_node().and_then(|n| n.as_element())\n }\n\n /// Get this node's parent element, or shadow host if it's a shadow root.\n fn parent_element_or_host(&self) -> Option {\n let parent = self.parent_node()?;\n if let Some(e) = parent.as_element() {\n return Some(e);\n }\n if let Some(root) = parent.as_shadow_root() {\n return Some(root.host());\n }\n None\n }\n\n /// Converts self into an `OpaqueNode`.\n fn opaque(&self) -> OpaqueNode;\n\n /// A debug id, only useful, mm... for debugging.\n fn debug_id(self) -> usize;\n\n /// Get this node as an element, if it's one.\n fn as_element(&self) -> Option;\n\n /// Get this node as a document, if it's one.\n fn as_document(&self) -> Option;\n\n /// Get this node as a ShadowRoot, if it's one.\n fn as_shadow_root(&self) -> Option;\n}\n\n/// Wrapper to output the subtree rather than the single node when formatting\n/// for Debug.\npub struct ShowSubtree(pub N);\nimpl Debug for ShowSubtree {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n writeln!(f, \"DOM Subtree:\")?;\n fmt_subtree(f, &|f, n| write!(f, \"{:?}\", n), self.0, 1)\n }\n}\n\n/// Wrapper to output the subtree along with the ElementData when formatting\n/// for Debug.\npub struct ShowSubtreeData(pub N);\nimpl Debug for ShowSubtreeData {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n writeln!(f, \"DOM Subtree:\")?;\n fmt_subtree(f, &|f, n| fmt_with_data(f, n), self.0, 1)\n }\n}\n\n/// Wrapper to output the subtree along with the ElementData and primary\n/// ComputedValues when formatting for Debug. This is extremely verbose.\n#[cfg(feature = \"servo\")]\npub struct ShowSubtreeDataAndPrimaryValues(pub N);\n#[cfg(feature = \"servo\")]\nimpl Debug for ShowSubtreeDataAndPrimaryValues {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n writeln!(f, \"DOM Subtree:\")?;\n fmt_subtree(f, &|f, n| fmt_with_data_and_primary_values(f, n), self.0, 1)\n }\n}\n\nfn fmt_with_data(f: &mut fmt::Formatter, n: N) -> fmt::Result {\n if let Some(el) = n.as_element() {\n write!(\n f,\n \"{:?} dd={} aodd={} data={:?}\",\n el,\n el.has_dirty_descendants(),\n el.has_animation_only_dirty_descendants(),\n el.borrow_data(),\n )\n } else {\n write!(f, \"{:?}\", n)\n }\n}\n\n#[cfg(feature = \"servo\")]\nfn fmt_with_data_and_primary_values(f: &mut fmt::Formatter, n: N) -> fmt::Result {\n if let Some(el) = n.as_element() {\n let dd = el.has_dirty_descendants();\n let aodd = el.has_animation_only_dirty_descendants();\n let data = el.borrow_data();\n let values = data.as_ref().and_then(|d| d.styles.get_primary());\n write!(\n f,\n \"{:?} dd={} aodd={} data={:?} values={:?}\",\n el, dd, aodd, &data, values\n )\n } else {\n write!(f, \"{:?}\", n)\n }\n}\n\nfn fmt_subtree(f: &mut fmt::Formatter, stringify: &F, n: N, indent: u32) -> fmt::Result\nwhere\n F: Fn(&mut fmt::Formatter, N) -> fmt::Result,\n{\n for _ in 0..indent {\n write!(f, \" \")?;\n }\n stringify(f, n)?;\n if let Some(e) = n.as_element() {\n for kid in e.traversal_children() {\n writeln!(f, \"\")?;\n fmt_subtree(f, stringify, kid, indent + 1)?;\n }\n }\n\n Ok(())\n}\n\n/// The ShadowRoot trait.\npub trait TShadowRoot: Sized + Copy + Clone + Debug + PartialEq {\n /// The concrete node type.\n type ConcreteNode: TNode;\n\n /// Get this ShadowRoot as a node.\n fn as_node(&self) -> Self::ConcreteNode;\n\n /// Get the shadow host that hosts this ShadowRoot.\n fn host(&self) -> ::ConcreteElement;\n\n /// Get the style data for this ShadowRoot.\n fn style_data<'a>(&self) -> Option<&'a CascadeData>\n where\n Self: 'a;\n\n /// Get the list of shadow parts for this shadow root.\n fn parts<'a>(&self) -> &[::ConcreteElement]\n where\n Self: 'a,\n {\n &[]\n }\n\n /// Get a list of elements with a given ID in this shadow root, sorted by\n /// tree position.\n ///\n /// Can return an error to signal that this list is not available, or also\n /// return an empty slice.\n fn elements_with_id<'a>(\n &self,\n _id: &AtomIdent,\n ) -> Result<&'a [::ConcreteElement], ()>\n where\n Self: 'a,\n {\n Err(())\n }\n\n /// Get the implicit scope for a stylesheet in given index.\n fn implicit_scope_for_sheet(&self, _sheet_index: usize) -> Option {\n None\n }\n}\n\n/// The element trait, the main abstraction the style crate acts over.\npub trait TElement:\n Eq\n + PartialEq\n + Debug\n + Hash\n + Sized\n + Copy\n + Clone\n + SelectorsElement\n + AttributeProvider\n{\n /// The concrete node type.\n type ConcreteNode: TNode;\n\n /// A concrete children iterator type in order to iterate over the `Node`s.\n ///\n /// TODO(emilio): We should eventually replace this with the `impl Trait`\n /// syntax.\n type TraversalChildrenIterator: Iterator;\n\n /// Get this element as a node.\n fn as_node(&self) -> Self::ConcreteNode;\n\n /// A debug-only check that the device's owner doc matches the actual doc\n /// we're the root of.\n ///\n /// Otherwise we may set document-level state incorrectly, like the root\n /// font-size used for rem units.\n fn owner_doc_matches_for_testing(&self, _: &Device) -> bool {\n true\n }\n\n /// Whether this element should match user and content rules.\n ///\n /// We use this for Native Anonymous Content in Gecko.\n fn matches_user_and_content_rules(&self) -> bool {\n true\n }\n\n /// Get this node's parent element from the perspective of a restyle\n /// traversal.\n fn traversal_parent(&self) -> Option {\n self.as_node().traversal_parent()\n }\n\n /// Get this node's children from the perspective of a restyle traversal.\n fn traversal_children(&self) -> LayoutIterator;\n\n /// Returns the parent element we should inherit from.\n ///\n /// This is pretty much always the parent element itself, except in the case\n /// of Gecko's Native Anonymous Content, which uses the traversal parent\n /// (i.e. the flattened tree parent) and which also may need to find the\n /// closest non-NAC ancestor.\n fn inheritance_parent(&self) -> Option {\n self.parent_element()\n }\n\n /// Execute `f` for each anonymous content child (apart from ::before and\n /// ::after) whose originating element is `self`.\n fn each_anonymous_content_child(&self, _f: F)\n where\n F: FnMut(Self),\n {\n }\n\n /// Return whether this element is an element in the HTML namespace.\n fn is_html_element(&self) -> bool;\n\n /// Return whether this element is an element in the MathML namespace.\n fn is_mathml_element(&self) -> bool;\n\n /// Return whether this element is an element in the SVG namespace.\n fn is_svg_element(&self) -> bool;\n\n /// Return whether this element is an element in the XUL namespace.\n fn is_xul_element(&self) -> bool {\n false\n }\n\n /// Returns the bloom filter for this element's subtree, used for fast\n /// querySelector optimization by allowing subtrees to be skipped.\n /// Each element's filter includes hashes for all of it's class names and\n /// attribute names (not values), along with the names for all descendent\n /// elements.\n ///\n /// The default implementation returns all bits set, meaning the bloom filter\n /// never filters anything.\n fn subtree_bloom_filter(&self) -> u64 {\n u64::MAX\n }\n\n /// Check if this element's subtree may contain elements with the given bloom hash.\n fn bloom_may_have_hash(&self, bloom_hash: u64) -> bool {\n let bloom = self.subtree_bloom_filter();\n (bloom & bloom_hash) == bloom_hash\n }\n\n /// Convert a 32-bit atom hash to a bloom filter value using k=2 hash functions.\n /// This must match the C++ implementation of HashForBloomFilter in Element.cpp\n fn hash_for_bloom_filter(hash: u32) -> u64 {\n // On 32-bit platforms, we have 31 bits available + 1 tag bit.\n // On 64-bit platforms, we have 63 bits available + 1 tag bit.\n #[cfg(target_pointer_width = \"32\")]\n const BLOOM_BITS: u32 = 31;\n\n #[cfg(target_pointer_width = \"64\")]\n const BLOOM_BITS: u32 = 63;\n\n let mut filter = 1u64;\n filter |= 1u64 << (1 + (hash % BLOOM_BITS));\n filter |= 1u64 << (1 + ((hash >> 6) % BLOOM_BITS));\n filter\n }\n\n /// Return the list of slotted nodes of this node.\n fn slotted_nodes(&self) -> &[Self::ConcreteNode] {\n &[]\n }\n\n /// Get this element's style attribute.\n fn style_attribute(&self) -> Option>>;\n\n /// Unset the style attribute's dirty bit.\n /// Servo doesn't need to manage ditry bit for style attribute.\n fn unset_dirty_style_attribute(&self) {}\n\n /// Get this element's SMIL override declarations.\n fn smil_override(&self) -> Option>> {\n None\n }\n\n /// Get the combined animation and transition rules.\n ///\n /// FIXME(emilio): Is this really useful?\n fn animation_declarations(&self, context: &SharedStyleContext) -> AnimationDeclarations {\n if !self.may_have_animations() {\n return Default::default();\n }\n\n AnimationDeclarations {\n animations: self.animation_rule(context),\n transitions: self.transition_rule(context),\n }\n }\n\n /// Get this element's animation rule.\n fn animation_rule(\n &self,\n _: &SharedStyleContext,\n ) -> Option>>;\n\n /// Get this element's transition rule.\n fn transition_rule(\n &self,\n context: &SharedStyleContext,\n ) -> Option>>;\n\n /// Get this element's state, for non-tree-structural pseudos.\n fn state(&self) -> ElementState;\n\n /// Returns whether this element has a `part` attribute.\n fn has_part_attr(&self) -> bool;\n\n /// Returns whether this element exports any part from its shadow tree.\n fn exports_any_part(&self) -> bool;\n\n /// The ID for this element.\n fn id(&self) -> Option<&WeakAtom>;\n\n /// Internal iterator for the classes of this element.\n fn each_class(&self, callback: F)\n where\n F: FnMut(&AtomIdent);\n\n /// Internal iterator for the classes of this element.\n fn each_custom_state(&self, callback: F)\n where\n F: FnMut(&AtomIdent);\n\n /// Internal iterator for the part names of this element.\n fn each_part(&self, _callback: F)\n where\n F: FnMut(&AtomIdent),\n {\n }\n\n /// Internal iterator for the attribute names of this element.\n fn each_attr_name(&self, callback: F)\n where\n F: FnMut(&LocalName);\n\n /// Internal iterator for the part names that this element exports for a\n /// given part name.\n fn each_exported_part(&self, _name: &AtomIdent, _callback: F)\n where\n F: FnMut(&AtomIdent),\n {\n }\n\n /// Whether a given element may generate a pseudo-element.\n ///\n /// This is useful to avoid computing, for example, pseudo styles for\n /// `::-first-line` or `::-first-letter`, when we know it won't affect us.\n ///\n /// TODO(emilio, bz): actually implement the logic for it.\n fn may_generate_pseudo(&self, pseudo: &PseudoElement, _primary_style: &ComputedValues) -> bool {\n // ::before/::after are always supported for now, though we could try to\n // optimize out leaf elements.\n\n // ::first-letter and ::first-line are only supported for block-inside\n // things, and only in Gecko, not Servo. Unfortunately, Gecko has\n // block-inside things that might have any computed display value due to\n // things like fieldsets, legends, etc. Need to figure out how this\n // should work.\n debug_assert!(\n pseudo.is_eager(),\n \"Someone called may_generate_pseudo with a non-eager pseudo.\"\n );\n true\n }\n\n /// Returns true if this element may have a descendant needing style processing.\n ///\n /// Note that we cannot guarantee the existence of such an element, because\n /// it may have been removed from the DOM between marking it for restyle and\n /// the actual restyle traversal.\n fn has_dirty_descendants(&self) -> bool;\n\n /// Returns whether state or attributes that may change style have changed\n /// on the element, and thus whether the element has been snapshotted to do\n /// restyle hint computation.\n fn has_snapshot(&self) -> bool;\n\n /// Returns whether the current snapshot if present has been handled.\n fn handled_snapshot(&self) -> bool;\n\n /// Flags this element as having handled already its snapshot.\n unsafe fn set_handled_snapshot(&self);\n\n /// Returns whether the element's styles are up-to-date after traversal\n /// (i.e. in post traversal).\n fn has_current_styles(&self, data: &ElementData) -> bool {\n if self.has_snapshot() && !self.handled_snapshot() {\n return false;\n }\n\n data.has_styles() &&\n // TODO(hiro): When an animating element moved into subtree of\n // contenteditable element, there remains animation restyle hints in\n // post traversal. It's generally harmless since the hints will be\n // processed in a next styling but ideally it should be processed soon.\n //\n // Without this, we get failures in:\n // layout/style/crashtests/1383319.html\n // layout/style/crashtests/1383001.html\n //\n // https://bugzilla.mozilla.org/show_bug.cgi?id=1389675 tracks fixing\n // this.\n !data.hint.has_non_animation_invalidations()\n }\n\n /// Flag that this element has a descendant for style processing.\n ///\n /// Only safe to call with exclusive access to the element.\n unsafe fn set_dirty_descendants(&self);\n\n /// Flag that this element has no descendant for style processing.\n ///\n /// Only safe to call with exclusive access to the element.\n unsafe fn unset_dirty_descendants(&self);\n\n /// Similar to the dirty_descendants but for representing a descendant of\n /// the element needs to be updated in animation-only traversal.\n fn has_animation_only_dirty_descendants(&self) -> bool {\n false\n }\n\n /// Flag that this element has a descendant for animation-only restyle\n /// processing.\n ///\n /// Only safe to call with exclusive access to the element.\n unsafe fn set_animation_only_dirty_descendants(&self) {}\n\n /// Flag that this element has no descendant for animation-only restyle processing.\n ///\n /// Only safe to call with exclusive access to the element.\n unsafe fn unset_animation_only_dirty_descendants(&self) {}\n\n /// Clear all bits related describing the dirtiness of descendants.\n ///\n /// In Gecko, this corresponds to the regular dirty descendants bit, the\n /// animation-only dirty descendants bit, and the lazy frame construction\n /// descendants bit.\n unsafe fn clear_descendant_bits(&self) {\n self.unset_dirty_descendants();\n }\n\n /// Returns true if this element is a visited link.\n ///\n /// Servo doesn't support visited styles yet.\n fn is_visited_link(&self) -> bool {\n false\n }\n\n /// Returns the pseudo-element implemented by this element, if any.\n ///\n /// Gecko traverses pseudo-elements during the style traversal, and we need\n /// to know this so we can properly grab the pseudo-element style from the\n /// parent element.\n ///\n /// Note that we still need to compute the pseudo-elements before-hand,\n /// given otherwise we don't know if we need to create an element or not.\n fn implemented_pseudo_element(&self) -> Option {\n None\n }\n\n /// Atomically stores the number of children of this node that we will\n /// need to process during bottom-up traversal.\n fn store_children_to_process(&self, n: isize);\n\n /// Atomically notes that a child has been processed during bottom-up\n /// traversal. Returns the number of children left to process.\n fn did_process_child(&self) -> isize;\n\n /// Gets a reference to the ElementData container, or creates one.\n ///\n /// Unsafe because it can race to allocate and leak if not used with\n /// exclusive access to the element.\n unsafe fn ensure_data(&self) -> ElementDataMut<'_>;\n\n /// Clears the element data reference, if any.\n ///\n /// Unsafe following the same reasoning as ensure_data.\n unsafe fn clear_data(&self);\n\n /// Whether there is an ElementData container.\n fn has_data(&self) -> bool;\n\n /// Immutably borrows the ElementData.\n fn borrow_data(&self) -> Option>;\n\n /// Mutably borrows the ElementData.\n fn mutate_data(&self) -> Option>;\n\n /// Whether we should skip any root- or item-based display property\n /// blockification on this element. (This function exists so that Gecko\n /// native anonymous content can opt out of this style fixup.)\n fn skip_item_display_fixup(&self) -> bool;\n\n /// In Gecko, element has a flag that represents the element may have\n /// any type of animations or not to bail out animation stuff early.\n /// Whereas Servo doesn't have such flag.\n fn may_have_animations(&self) -> bool;\n\n /// Creates a task to update various animation state on a given (pseudo-)element.\n #[cfg(feature = \"gecko\")]\n fn update_animations(\n &self,\n before_change_style: Option>,\n tasks: UpdateAnimationsTasks,\n );\n\n /// Returns true if the element has relevant animations. Relevant\n /// animations are those animations that are affecting the element's style\n /// or are scheduled to do so in the future.\n fn has_animations(&self, context: &SharedStyleContext) -> bool;\n\n /// Returns true if the element has a CSS animation. The `context` and `pseudo_element`\n /// arguments are only used by Servo, since it stores animations globally and pseudo-elements\n /// are not in the DOM.\n fn has_css_animations(\n &self,\n context: &SharedStyleContext,\n pseudo_element: Option,\n ) -> bool;\n\n /// Returns true if the element has a CSS transition (including running transitions and\n /// completed transitions). The `context` and `pseudo_element` arguments are only used\n /// by Servo, since it stores animations globally and pseudo-elements are not in the DOM.\n fn has_css_transitions(\n &self,\n context: &SharedStyleContext,\n pseudo_element: Option,\n ) -> bool;\n\n /// Returns true if the element has animation restyle hints.\n fn has_animation_restyle_hints(&self) -> bool {\n let data = match self.borrow_data() {\n Some(d) => d,\n None => return false,\n };\n return data.hint.has_animation_hint();\n }\n\n /// Called when a highlight pseudo-element (::selection, ::highlight,\n /// ::target-text) style is invalidated. These pseudos need explicit repaint\n /// triggering since their styles are resolved lazily during painting.\n fn note_highlight_pseudo_style_invalidated(&self) {}\n\n /// The shadow root this element is a host of.\n fn shadow_root(&self) -> Option<::ConcreteShadowRoot>;\n\n /// The shadow root which roots the subtree this element is contained in.\n fn containing_shadow(&self) -> Option<::ConcreteShadowRoot>;\n\n /// Return the element which we can use to look up rules in the selector\n /// maps.\n ///\n /// This is always the element itself, except in the case where we are an\n /// element-backed pseudo-element, in which case we return the originating\n /// element.\n fn rule_hash_target(&self) -> Self {\n let mut cur = *self;\n while cur.is_pseudo_element() {\n cur = cur\n .pseudo_element_originating_element()\n .expect(\"Trying to collect rules for a detached pseudo-element\")\n }\n cur\n }\n\n /// Executes the callback for each applicable style rule data which isn't\n /// the main document's data (which stores UA / author rules).\n ///\n /// The element passed to the callback is the containing shadow host for the\n /// data if it comes from Shadow DOM.\n ///\n /// Returns whether normal document author rules should apply.\n ///\n /// TODO(emilio): We could separate the invalidation data for elements\n /// matching in other scopes to avoid over-invalidation.\n fn each_applicable_non_document_style_rule_data<'a, F>(&self, mut f: F) -> bool\n where\n Self: 'a,\n F: FnMut(&'a CascadeData, Self),\n {\n use crate::rule_collector::containing_shadow_ignoring_svg_use;\n\n let target = self.rule_hash_target();\n let matches_user_and_content_rules = target.matches_user_and_content_rules();\n let mut doc_rules_apply = matches_user_and_content_rules;\n\n // Use the same rules to look for the containing host as we do for rule\n // collection.\n if let Some(shadow) = containing_shadow_ignoring_svg_use(target) {\n doc_rules_apply = false;\n if let Some(data) = shadow.style_data() {\n f(data, shadow.host());\n }\n }\n\n if let Some(shadow) = target.shadow_root() {\n if let Some(data) = shadow.style_data() {\n f(data, shadow.host());\n }\n }\n\n let mut current = target.assigned_slot();\n while let Some(slot) = current {\n // Slots can only have assigned nodes when in a shadow tree.\n let shadow = slot.containing_shadow().unwrap();\n if let Some(data) = shadow.style_data() {\n if data.any_slotted_rule() {\n f(data, shadow.host());\n }\n }\n current = slot.assigned_slot();\n }\n\n if target.has_part_attr() {\n if let Some(mut inner_shadow) = target.containing_shadow() {\n loop {\n let inner_shadow_host = inner_shadow.host();\n match inner_shadow_host.containing_shadow() {\n Some(shadow) => {\n if let Some(data) = shadow.style_data() {\n if data.any_part_rule() {\n f(data, shadow.host())\n }\n }\n // TODO: Could be more granular.\n if !inner_shadow_host.exports_any_part() {\n break;\n }\n inner_shadow = shadow;\n },\n None => {\n // TODO(emilio): Should probably distinguish with\n // MatchesDocumentRules::{No,Yes,IfPart} or something so that we could\n // skip some work.\n doc_rules_apply = matches_user_and_content_rules;\n break;\n },\n }\n }\n }\n }\n\n doc_rules_apply\n }\n\n /// Returns true if one of the transitions needs to be updated on this element. We check all\n /// the transition properties to make sure that updating transitions is necessary.\n /// This method should only be called if might_needs_transitions_update returns true when\n /// passed the same parameters.\n #[cfg(feature = \"gecko\")]\n fn needs_transitions_update(\n &self,\n before_change_style: &ComputedValues,\n after_change_style: &ComputedValues,\n ) -> bool;\n\n /// Returns the value of the `xml:lang=\"\"` attribute (or, if appropriate,\n /// the `lang=\"\"` attribute) on this element.\n fn lang_attr(&self) -> Option;\n\n /// Returns whether this element's language matches the language tag\n /// `value`. If `override_lang` is not `None`, it specifies the value\n /// of the `xml:lang=\"\"` or `lang=\"\"` attribute to use in place of\n /// looking at the element and its ancestors. (This argument is used\n /// to implement matching of `:lang()` against snapshots.)\n fn match_element_lang(&self, override_lang: Option>, value: &Lang) -> bool;\n\n /// Returns whether this element is the main body element of the HTML\n /// document it is on.\n fn is_html_document_body_element(&self) -> bool;\n\n /// Generate the proper applicable declarations due to presentational hints,\n /// and insert them into `hints`.\n fn synthesize_presentational_hints_for_legacy_attributes(\n &self,\n visited_handling: VisitedHandlingMode,\n hints: &mut V,\n ) where\n V: Push;\n\n /// Generate the proper applicable declarations due to view transition dynamic rules, and\n /// insert them into `rules`.\n /// https://drafts.csswg.org/css-view-transitions-1/#document-dynamic-view-transition-style-sheet\n fn synthesize_view_transition_dynamic_rules(&self, _rules: &mut V)\n where\n V: Push,\n {\n }\n\n /// Returns element's local name.\n fn local_name(&self) -> &::BorrowedLocalName;\n\n /// Returns element's namespace.\n fn namespace(&self)\n -> &::BorrowedNamespaceUrl;\n\n /// Returns the size of the element to be used in container size queries.\n /// This will usually be the size of the content area of the primary box,\n /// but can be None if there is no box or if some axis lacks size containment.\n fn query_container_size(\n &self,\n display: &Display,\n ) -> euclid::default::Size2D>;\n\n /// Returns true if the element has all of specified selector flags.\n fn has_selector_flags(&self, flags: ElementSelectorFlags) -> bool;\n\n /// Returns the search direction for relative selector invalidation, if it is on the search path.\n fn relative_selector_search_direction(&self) -> ElementSelectorFlags;\n\n /// Returns the implicit scope root for given sheet index and host.\n fn implicit_scope_for_sheet_in_shadow_root(\n _opaque_host: OpaqueElement,\n _sheet_index: usize,\n ) -> Option {\n None\n }\n\n /// Compute the damage incurred by the change from the `_old` to `_new`.\n fn compute_layout_damage(_old: &ComputedValues, _new: &ComputedValues) -> RestyleDamage {\n Default::default()\n }\n}\n\n/// The attribute provider trait\npub trait AttributeProvider {\n /// Return the value of the given custom attibute if it exists.\n fn get_attr(&self, attr: &LocalName, namespace: &Namespace) -> Option;\n}\n\n/// A set of the attributes used to compute a style that uses `attr()`\npub type AttributeReferences = Option>>>;\n\n/// A data structure to keep track of the names queried from a provider.\npub struct AttributeTracker<'a> {\n /// The element that queries for attributes.\n pub provider: &'a dyn AttributeProvider,\n /// The set of attributes we have queried.\n pub references: AttributeReferences,\n}\n\nimpl<'a> AttributeTracker<'a> {\n /// Construct a new attribute tracker trivially.\n pub fn new(provider: &'a dyn AttributeProvider) -> Self {\n Self {\n provider,\n references: None,\n }\n }\n\n /// Consstruct a new dummy attribute tracker\n pub fn new_dummy() -> Self {\n Self {\n provider: &DummyAttributeProvider {},\n references: None,\n }\n }\n\n /// Extract the queried references and consume self\n pub fn finalize(self) -> AttributeReferences {\n self.references\n }\n\n /// Query the value and save the name of the attribtue.\n pub fn query(&mut self, name: &LocalName, namespace: &Namespace) -> Option {\n // We need to save namespaces in case we are thinking of sharing this element's\n // style with another.\n // i.e if elment a has ns1::attr=\"blue\"\n // and element b has ns2::attr=\"blue\"\n // a and b can only share style if ns1 and ns2 resolve to the same namespace.\n self.references\n .get_or_insert_default()\n .entry(name.clone())\n .or_default()\n .push(namespace.clone());\n self.provider.get_attr(name, namespace)\n }\n}\n\n/// A dummy AttributeProvider that returns none to any attribute query.\n#[derive(Clone, Debug, PartialEq)]\nstruct DummyAttributeProvider;\n\nimpl AttributeProvider for DummyAttributeProvider {\n fn get_attr(&self, _attr: &LocalName, _namespace: &Namespace) -> Option {\n None\n }\n}\n\n/// TNode and TElement aren't Send because we want to be careful and explicit\n/// about our parallel traversal. However, there are certain situations\n/// (including but not limited to the traversal) where we need to send DOM\n/// objects to other threads.\n///\n/// That's the reason why `SendNode` exists.\n#[derive(Clone, Debug, PartialEq)]\npub struct SendNode(N);\nunsafe impl Send for SendNode {}\nimpl SendNode {\n /// Unsafely construct a SendNode.\n pub unsafe fn new(node: N) -> Self {\n SendNode(node)\n }\n}\nimpl Deref for SendNode {\n type Target = N;\n fn deref(&self) -> &N {\n &self.0\n }\n}\n\n/// Same reason as for the existence of SendNode, SendElement does the proper\n/// things for a given `TElement`.\n#[derive(Debug, Eq, Hash, PartialEq)]\npub struct SendElement(E);\nunsafe impl Send for SendElement {}\nimpl SendElement {\n /// Unsafely construct a SendElement.\n pub unsafe fn new(el: E) -> Self {\n SendElement(el)\n }\n}\nimpl Deref for SendElement {\n type Target = E;\n fn deref(&self) -> &E {\n &self.0\n }\n}\n" }, { "path": "style/dom_apis.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! Generic implementations of some DOM APIs so they can be shared between Servo\n//! and Gecko.\n\nuse crate::context::QuirksMode;\nuse crate::dom::{TDocument, TElement, TNode, TShadowRoot};\nuse crate::invalidation::element::invalidation_map::Dependency;\nuse crate::invalidation::element::invalidator::{\n DescendantInvalidationLists, Invalidation, SiblingTraversalMap,\n};\nuse crate::invalidation::element::invalidator::{InvalidationProcessor, InvalidationVector};\nuse crate::selector_parser::SelectorImpl;\nuse crate::values::AtomIdent;\nuse selectors::attr::CaseSensitivity;\nuse selectors::attr::{AttrSelectorOperation, NamespaceConstraint};\nuse selectors::matching::{\n self, MatchingContext, MatchingForInvalidation, MatchingMode, NeedsSelectorFlags,\n SelectorCaches,\n};\nuse selectors::parser::{Combinator, Component, LocalName};\nuse selectors::{Element, OpaqueElement, SelectorList};\nuse smallvec::SmallVec;\n\n/// \npub fn element_matches(\n element: &E,\n selector_list: &SelectorList,\n quirks_mode: QuirksMode,\n) -> bool\nwhere\n E: Element,\n{\n let mut selector_caches = SelectorCaches::default();\n\n let mut context = MatchingContext::new(\n MatchingMode::Normal,\n None,\n &mut selector_caches,\n quirks_mode,\n NeedsSelectorFlags::No,\n MatchingForInvalidation::No,\n );\n context.scope_element = Some(element.opaque());\n context.current_host = element.containing_shadow_host().map(|e| e.opaque());\n matching::matches_selector_list(selector_list, element, &mut context)\n}\n\n/// \npub fn element_closest(\n element: E,\n selector_list: &SelectorList,\n quirks_mode: QuirksMode,\n) -> Option\nwhere\n E: Element,\n{\n let mut selector_caches = SelectorCaches::default();\n\n let mut context = MatchingContext::new(\n MatchingMode::Normal,\n None,\n &mut selector_caches,\n quirks_mode,\n NeedsSelectorFlags::No,\n MatchingForInvalidation::No,\n );\n context.scope_element = Some(element.opaque());\n context.current_host = element.containing_shadow_host().map(|e| e.opaque());\n\n let mut current = Some(element);\n while let Some(element) = current.take() {\n if matching::matches_selector_list(selector_list, &element, &mut context) {\n return Some(element);\n }\n current = element.parent_element();\n }\n\n return None;\n}\n\n/// A selector query abstraction, in order to be generic over QuerySelector and\n/// QuerySelectorAll.\npub trait SelectorQuery {\n /// The output of the query.\n type Output;\n\n /// Whether the query should stop after the first element has been matched.\n fn should_stop_after_first_match() -> bool;\n\n /// Append an element matching after the first query.\n fn append_element(output: &mut Self::Output, element: E);\n\n /// Returns true if the output is empty.\n fn is_empty(output: &Self::Output) -> bool;\n}\n\n/// The result of a querySelectorAll call.\npub type QuerySelectorAllResult = SmallVec<[E; 128]>;\n\n/// A query for all the elements in a subtree.\npub struct QueryAll;\n\nimpl SelectorQuery for QueryAll {\n type Output = QuerySelectorAllResult;\n\n fn should_stop_after_first_match() -> bool {\n false\n }\n\n fn append_element(output: &mut Self::Output, element: E) {\n output.push(element);\n }\n\n fn is_empty(output: &Self::Output) -> bool {\n output.is_empty()\n }\n}\n\n/// A query for the first in-tree match of all the elements in a subtree.\npub struct QueryFirst;\n\nimpl SelectorQuery for QueryFirst {\n type Output = Option;\n\n fn should_stop_after_first_match() -> bool {\n true\n }\n\n fn append_element(output: &mut Self::Output, element: E) {\n if output.is_none() {\n *output = Some(element)\n }\n }\n\n fn is_empty(output: &Self::Output) -> bool {\n output.is_none()\n }\n}\n\nstruct QuerySelectorProcessor<'a, 'b, E, Q>\nwhere\n E: TElement + 'a,\n Q: SelectorQuery,\n Q::Output: 'a,\n{\n results: &'a mut Q::Output,\n matching_context: MatchingContext<'b, E::Impl>,\n traversal_map: SiblingTraversalMap,\n dependencies: &'a [Dependency],\n}\n\nimpl<'a, 'b, E, Q> InvalidationProcessor<'a, 'b, E> for QuerySelectorProcessor<'a, 'b, E, Q>\nwhere\n E: TElement + 'a,\n Q: SelectorQuery,\n Q::Output: 'a,\n{\n fn light_tree_only(&self) -> bool {\n true\n }\n\n fn check_outer_dependency(&mut self, _: &Dependency, _: E, _: Option) -> bool {\n debug_assert!(\n false,\n \"How? We should only have parent-less dependencies here!\"\n );\n true\n }\n\n fn collect_invalidations(\n &mut self,\n element: E,\n self_invalidations: &mut InvalidationVector<'a>,\n descendant_invalidations: &mut DescendantInvalidationLists<'a>,\n _sibling_invalidations: &mut InvalidationVector<'a>,\n ) -> bool {\n // TODO(emilio): If the element is not a root element, and\n // selector_list has any descendant combinator, we need to do extra work\n // in order to handle properly things like:\n //\n //
\n //
\n //
\n //
\n //
\n //\n // b.querySelector('#a div'); // Should return \"c\".\n //\n // For now, assert it's a root element.\n debug_assert!(element.parent_element().is_none());\n\n let target_vector = if self.matching_context.scope_element.is_some() {\n &mut descendant_invalidations.dom_descendants\n } else {\n self_invalidations\n };\n\n for dependency in self.dependencies.iter() {\n target_vector.push(Invalidation::new(\n dependency,\n self.matching_context.current_host.clone(),\n self.matching_context.scope_element.clone(),\n ))\n }\n\n false\n }\n\n fn matching_context(&mut self) -> &mut MatchingContext<'b, E::Impl> {\n &mut self.matching_context\n }\n\n fn sibling_traversal_map(&self) -> &SiblingTraversalMap {\n &self.traversal_map\n }\n\n fn should_process_descendants(&mut self, _: E) -> bool {\n if Q::should_stop_after_first_match() {\n return Q::is_empty(&self.results);\n }\n\n true\n }\n\n fn invalidated_self(&mut self, e: E) {\n Q::append_element(self.results, e);\n }\n\n fn invalidated_sibling(&mut self, e: E, _of: E) {\n Q::append_element(self.results, e);\n }\n\n fn recursion_limit_exceeded(&mut self, _e: E) {}\n fn invalidated_descendants(&mut self, _e: E, _child: E) {}\n}\n\nenum Operation {\n Reject,\n Accept,\n RejectSkippingChildren,\n}\n\nimpl From for Operation {\n #[inline(always)]\n fn from(matches: bool) -> Self {\n if matches {\n Operation::Accept\n } else {\n Operation::Reject\n }\n }\n}\n\nfn collect_all_elements(root: E::ConcreteNode, results: &mut Q::Output, mut filter: F)\nwhere\n E: TElement,\n Q: SelectorQuery,\n F: FnMut(E) -> Operation,\n{\n let mut iter = root.dom_descendants();\n let mut cur = iter.next();\n while let Some(node) = cur {\n let element = match node.as_element() {\n Some(e) => e,\n None => {\n cur = iter.next();\n continue;\n },\n };\n match filter(element) {\n // Element matches - add to results and continue traversing its children.\n Operation::Accept => {\n Q::append_element(results, element);\n if Q::should_stop_after_first_match() {\n return;\n }\n },\n // Element doesn't match - skip it but continue traversing its children.\n Operation::Reject => {},\n // Element doesn't match and skip entire subtree.\n Operation::RejectSkippingChildren => {\n cur = iter.next_skipping_children();\n continue;\n },\n }\n cur = iter.next();\n }\n}\n\n/// Returns whether a given element connected to `root` is descendant of `root`.\n///\n/// NOTE(emilio): if root == element, this returns false.\nfn connected_element_is_descendant_of(element: E, root: E::ConcreteNode) -> bool\nwhere\n E: TElement,\n{\n // Optimize for when the root is a document or a shadow root and the element\n // is connected to that root.\n if root.as_document().is_some() {\n debug_assert!(element.as_node().is_in_document(), \"Not connected?\");\n debug_assert_eq!(\n root,\n root.owner_doc().as_node(),\n \"Where did this element come from?\",\n );\n return true;\n }\n\n if root.as_shadow_root().is_some() {\n debug_assert_eq!(\n element.containing_shadow().unwrap().as_node(),\n root,\n \"Not connected?\"\n );\n return true;\n }\n\n let mut current = element.as_node().parent_node();\n while let Some(n) = current.take() {\n if n == root {\n return true;\n }\n\n current = n.parent_node();\n }\n false\n}\n\n/// Fast path for iterating over every element with a given id in the document\n/// or shadow root that `root` is connected to.\nfn fast_connected_elements_with_id<'a, N>(\n root: N,\n id: &AtomIdent,\n case_sensitivity: CaseSensitivity,\n) -> Result<&'a [N::ConcreteElement], ()>\nwhere\n N: TNode + 'a,\n{\n if case_sensitivity != CaseSensitivity::CaseSensitive {\n return Err(());\n }\n\n if root.is_in_document() {\n return root.owner_doc().elements_with_id(id);\n }\n\n if let Some(shadow) = root.as_shadow_root() {\n return shadow.elements_with_id(id);\n }\n\n if let Some(shadow) = root.as_element().and_then(|e| e.containing_shadow()) {\n return shadow.elements_with_id(id);\n }\n\n Err(())\n}\n\n/// Collects elements with a given id under `root`, that pass `filter`.\nfn collect_elements_with_id(\n root: E::ConcreteNode,\n id: &AtomIdent,\n results: &mut Q::Output,\n class_and_id_case_sensitivity: CaseSensitivity,\n mut filter: F,\n) where\n E: TElement,\n Q: SelectorQuery,\n F: FnMut(E) -> bool,\n{\n let elements = match fast_connected_elements_with_id(root, id, class_and_id_case_sensitivity) {\n Ok(elements) => elements,\n Err(()) => {\n collect_all_elements::(root, results, |e| {\n Operation::from(e.has_id(id, class_and_id_case_sensitivity) && filter(e))\n });\n\n return;\n },\n };\n\n for element in elements {\n // If the element is not an actual descendant of the root, even though\n // it's connected, we don't really care about it.\n if !connected_element_is_descendant_of(*element, root) {\n continue;\n }\n\n if !filter(*element) {\n continue;\n }\n\n Q::append_element(results, *element);\n if Q::should_stop_after_first_match() {\n break;\n }\n }\n}\n\nfn has_attr(element: E, local_name: &crate::LocalName) -> bool\nwhere\n E: TElement,\n{\n let mut found = false;\n element.each_attr_name(|name| found |= name == local_name);\n found\n}\n\n#[inline(always)]\nfn local_name_matches(element: E, local_name: &LocalName) -> bool\nwhere\n E: TElement,\n{\n let LocalName {\n ref name,\n ref lower_name,\n } = *local_name;\n\n let chosen_name = if name == lower_name || element.is_html_element_in_html_document() {\n lower_name\n } else {\n name\n };\n\n element.local_name() == &**chosen_name\n}\n\nfn get_attr_name(component: &Component) -> Option<&crate::LocalName> {\n let (name, name_lower) = match component {\n Component::AttributeInNoNamespace { ref local_name, .. } => return Some(local_name),\n Component::AttributeInNoNamespaceExists {\n ref local_name,\n ref local_name_lower,\n ..\n } => (local_name, local_name_lower),\n Component::AttributeOther(ref attr) => (&attr.local_name, &attr.local_name_lower),\n _ => return None,\n };\n if name != name_lower {\n return None; // TODO: Maybe optimize this?\n }\n Some(name)\n}\n\nfn get_id(component: &Component) -> Option<&AtomIdent> {\n use selectors::attr::AttrSelectorOperator;\n Some(match component {\n Component::ID(ref id) => id,\n Component::AttributeInNoNamespace {\n ref operator,\n ref local_name,\n ref value,\n ..\n } => {\n if *local_name != local_name!(\"id\") {\n return None;\n }\n if *operator != AttrSelectorOperator::Equal {\n return None;\n }\n AtomIdent::cast(&value.0)\n },\n _ => return None,\n })\n}\n\n/// Fast paths for querySelector with a single simple selector.\nfn query_selector_single_query(\n root: E::ConcreteNode,\n component: &Component,\n results: &mut Q::Output,\n class_and_id_case_sensitivity: CaseSensitivity,\n) -> Result<(), ()>\nwhere\n E: TElement,\n Q: SelectorQuery,\n{\n match *component {\n Component::ExplicitUniversalType => {\n collect_all_elements::(root, results, |_| Operation::Accept)\n },\n Component::Class(ref class) => {\n // Bloom filter can only be used when case sensitive.\n let bloom_hash = if class_and_id_case_sensitivity == CaseSensitivity::CaseSensitive {\n Some(E::hash_for_bloom_filter(class.0.get_hash()))\n } else {\n None\n };\n\n collect_all_elements::(root, results, |element| {\n if bloom_hash.is_some_and(|hash| !element.bloom_may_have_hash(hash)) {\n return Operation::RejectSkippingChildren;\n }\n Operation::from(element.has_class(class, class_and_id_case_sensitivity))\n });\n },\n Component::LocalName(ref local_name) => {\n collect_all_elements::(root, results, |element| {\n Operation::from(local_name_matches(element, local_name))\n })\n },\n Component::AttributeInNoNamespaceExists {\n ref local_name,\n ref local_name_lower,\n } => {\n // For HTML elements: C++ hashes lowercase\n // For XUL/SVG/MathML elements: C++ hashes original case\n let hash_original = E::hash_for_bloom_filter(local_name.0.get_hash());\n let hash_lower = if local_name.0 == local_name_lower.0 {\n hash_original\n } else {\n E::hash_for_bloom_filter(local_name_lower.0.get_hash())\n };\n\n collect_all_elements::(root, results, |element| {\n // Check bloom filter first\n let bloom_found_hash = if hash_original == hash_lower\n || !element.as_node().owner_doc().is_html_document()\n {\n element.bloom_may_have_hash(hash_original)\n } else if element.is_html_element_in_html_document() {\n // HTML elements store lowercase hashes\n element.bloom_may_have_hash(hash_lower)\n } else {\n // Non-HTML elements in HTML documents might have HTML descendants\n // with lowercase-only hashes, so check both\n element.bloom_may_have_hash(hash_original)\n || element.bloom_may_have_hash(hash_lower)\n };\n\n if !bloom_found_hash {\n return Operation::RejectSkippingChildren;\n }\n\n Operation::from(element.has_attr_in_no_namespace(matching::select_name(\n &element,\n local_name,\n local_name_lower,\n )))\n });\n },\n Component::AttributeInNoNamespace {\n ref local_name,\n ref value,\n operator,\n case_sensitivity,\n } => {\n let empty_namespace = selectors::parser::namespace_empty_string::();\n let namespace_constraint = NamespaceConstraint::Specific(&empty_namespace);\n\n // Only use bloom filter to check for attribute name existence.\n let bloom_hash = E::hash_for_bloom_filter(local_name.0.get_hash());\n\n collect_all_elements::(root, results, |element| {\n if !element.bloom_may_have_hash(bloom_hash) {\n return Operation::RejectSkippingChildren;\n }\n Operation::from(element.attr_matches(\n &namespace_constraint,\n local_name,\n &AttrSelectorOperation::WithValue {\n operator,\n case_sensitivity: matching::to_unconditional_case_sensitivity(\n case_sensitivity,\n &element,\n ),\n value,\n },\n ))\n });\n },\n ref other => {\n let id = match get_id(other) {\n Some(id) => id,\n // TODO(emilio): More fast paths?\n None => return Err(()),\n };\n collect_elements_with_id::(\n root,\n id,\n results,\n class_and_id_case_sensitivity,\n |_| true,\n );\n },\n }\n\n Ok(())\n}\n\nenum SimpleFilter<'a> {\n Class(&'a AtomIdent),\n Attr(&'a crate::LocalName),\n LocalName(&'a LocalName),\n}\n\n/// Fast paths for a given selector query.\n///\n/// When there's only one component, we go directly to\n/// `query_selector_single_query`, otherwise, we try to optimize by looking just\n/// at the subtrees rooted at ids in the selector, and otherwise we try to look\n/// up by class name or local name in the rightmost compound.\n///\n/// FIXME(emilio, nbp): This may very well be a good candidate for code to be\n/// replaced by HolyJit :)\nfn query_selector_fast(\n root: E::ConcreteNode,\n selector_list: &SelectorList,\n results: &mut Q::Output,\n matching_context: &mut MatchingContext,\n) -> Result<(), ()>\nwhere\n E: TElement,\n Q: SelectorQuery,\n{\n // We need to return elements in document order, and reordering them\n // afterwards is kinda silly.\n if selector_list.len() > 1 {\n return Err(());\n }\n\n let selector = &selector_list.slice()[0];\n let class_and_id_case_sensitivity = matching_context.classes_and_ids_case_sensitivity();\n // Let's just care about the easy cases for now.\n if selector.len() == 1 {\n if query_selector_single_query::(\n root,\n selector.iter().next().unwrap(),\n results,\n class_and_id_case_sensitivity,\n )\n .is_ok()\n {\n return Ok(());\n }\n }\n\n let mut iter = selector.iter();\n let mut combinator: Option = None;\n\n // We want to optimize some cases where there's no id involved whatsoever,\n // like `.foo .bar`, but we don't want to make `#foo .bar` slower because of\n // that.\n let mut simple_filter = None;\n\n 'selector_loop: loop {\n debug_assert!(combinator.map_or(true, |c| !c.is_sibling()));\n\n 'component_loop: for component in &mut iter {\n match *component {\n Component::Class(ref class) => {\n if combinator.is_none() {\n simple_filter = Some(SimpleFilter::Class(class));\n }\n },\n Component::LocalName(ref local_name) => {\n if combinator.is_none() {\n // Prefer to look at class rather than local-name if\n // both are present.\n if let Some(SimpleFilter::Class(..)) = simple_filter {\n continue;\n }\n simple_filter = Some(SimpleFilter::LocalName(local_name));\n }\n },\n ref other => {\n if let Some(id) = get_id(other) {\n if combinator.is_none() {\n // In the rightmost compound, just find descendants of root that match\n // the selector list with that id.\n collect_elements_with_id::(\n root,\n id,\n results,\n class_and_id_case_sensitivity,\n |e| {\n matching::matches_selector_list(\n selector_list,\n &e,\n matching_context,\n )\n },\n );\n return Ok(());\n }\n\n let elements = fast_connected_elements_with_id(\n root,\n id,\n class_and_id_case_sensitivity,\n )?;\n if elements.is_empty() {\n return Ok(());\n }\n\n // Results need to be in document order. Let's not bother\n // reordering or deduplicating nodes, which we would need to\n // do if one element with the given id were a descendant of\n // another element with that given id.\n if !Q::should_stop_after_first_match() && elements.len() > 1 {\n continue;\n }\n\n for element in elements {\n // If the element is not a descendant of the root, then\n // it may have descendants that match our selector that\n // _are_ descendants of the root, and other descendants\n // that match our selector that are _not_.\n //\n // So we can't just walk over the element's descendants\n // and match the selector against all of them, nor can\n // we skip looking at this element's descendants.\n //\n // Give up on trying to optimize based on this id and\n // keep walking our selector.\n if !connected_element_is_descendant_of(*element, root) {\n continue 'component_loop;\n }\n\n query_selector_slow::(\n element.as_node(),\n selector_list,\n results,\n matching_context,\n );\n\n if Q::should_stop_after_first_match() && !Q::is_empty(&results) {\n break;\n }\n }\n\n return Ok(());\n }\n if combinator.is_none() && simple_filter.is_none() {\n if let Some(attr_name) = get_attr_name(other) {\n simple_filter = Some(SimpleFilter::Attr(attr_name));\n }\n }\n },\n }\n }\n\n loop {\n let next_combinator = match iter.next_sequence() {\n None => break 'selector_loop,\n Some(c) => c,\n };\n\n // We don't want to scan stuff affected by sibling combinators,\n // given we scan the subtree of elements with a given id (and we\n // don't want to care about scanning the siblings' subtrees).\n if next_combinator.is_sibling() {\n // Advance to the next combinator.\n for _ in &mut iter {}\n continue;\n }\n\n combinator = Some(next_combinator);\n break;\n }\n }\n\n // We got here without finding any ID or such that we could handle. Try to\n // use one of the simple filters.\n let simple_filter = match simple_filter {\n Some(f) => f,\n None => return Err(()),\n };\n\n match simple_filter {\n SimpleFilter::Class(ref class) => {\n collect_all_elements::(root, results, |element| {\n Operation::from(\n element.has_class(class, class_and_id_case_sensitivity)\n && matching::matches_selector_list(\n selector_list,\n &element,\n matching_context,\n ),\n )\n });\n },\n SimpleFilter::LocalName(ref local_name) => {\n collect_all_elements::(root, results, |element| {\n Operation::from(\n local_name_matches(element, local_name)\n && matching::matches_selector_list(\n selector_list,\n &element,\n matching_context,\n ),\n )\n });\n },\n SimpleFilter::Attr(ref local_name) => {\n collect_all_elements::(root, results, |element| {\n Operation::from(\n has_attr(element, local_name)\n && matching::matches_selector_list(\n selector_list,\n &element,\n matching_context,\n ),\n )\n });\n },\n }\n\n Ok(())\n}\n\n// Slow path for a given selector query.\nfn query_selector_slow(\n root: E::ConcreteNode,\n selector_list: &SelectorList,\n results: &mut Q::Output,\n matching_context: &mut MatchingContext,\n) where\n E: TElement,\n Q: SelectorQuery,\n{\n collect_all_elements::(root, results, |element| {\n Operation::from(matching::matches_selector_list(\n selector_list,\n &element,\n matching_context,\n ))\n });\n}\n\n/// Whether the invalidation machinery should be used for this query.\n#[derive(PartialEq)]\npub enum MayUseInvalidation {\n /// We may use it if we deem it useful.\n Yes,\n /// Don't use it.\n No,\n}\n\n/// \npub fn query_selector(\n root: E::ConcreteNode,\n selector_list: &SelectorList,\n results: &mut Q::Output,\n may_use_invalidation: MayUseInvalidation,\n) where\n E: TElement,\n Q: SelectorQuery,\n{\n use crate::invalidation::element::invalidator::TreeStyleInvalidator;\n\n let mut selector_caches = SelectorCaches::default();\n let quirks_mode = root.owner_doc().quirks_mode();\n\n let mut matching_context = MatchingContext::new(\n MatchingMode::Normal,\n None,\n &mut selector_caches,\n quirks_mode,\n NeedsSelectorFlags::No,\n MatchingForInvalidation::No,\n );\n let root_element = root.as_element();\n matching_context.scope_element = root_element.map(|e| e.opaque());\n matching_context.current_host = match root_element {\n Some(root) => root.containing_shadow_host().map(|host| host.opaque()),\n None => root.as_shadow_root().map(|root| root.host().opaque()),\n };\n\n let fast_result =\n query_selector_fast::(root, selector_list, results, &mut matching_context);\n\n if fast_result.is_ok() {\n return;\n }\n\n // Slow path: Use the invalidation machinery if we're a root, and tree\n // traversal otherwise.\n //\n // See the comment in collect_invalidations to see why only if we're a root.\n //\n // The invalidation mechanism is only useful in presence of combinators.\n //\n // We could do that check properly here, though checking the length of the\n // selectors is a good heuristic.\n //\n // A selector with a combinator needs to have a length of at least 3: A\n // simple selector, a combinator, and another simple selector.\n let invalidation_may_be_useful = may_use_invalidation == MayUseInvalidation::Yes\n && selector_list.slice().iter().any(|s| s.len() > 2);\n\n if root_element.is_some() || !invalidation_may_be_useful {\n query_selector_slow::(root, selector_list, results, &mut matching_context);\n } else {\n let dependencies = selector_list\n .slice()\n .iter()\n .map(|selector| Dependency::for_full_selector_invalidation(selector.clone()))\n .collect::>();\n let mut processor = QuerySelectorProcessor:: {\n results,\n matching_context,\n traversal_map: SiblingTraversalMap::default(),\n dependencies: &dependencies,\n };\n\n for node in root.dom_children() {\n if let Some(e) = node.as_element() {\n TreeStyleInvalidator::new(e, /* stack_limit_checker = */ None, &mut processor)\n .invalidate();\n }\n }\n }\n}\n" }, { "path": "style/driver.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! Implements traversal over the DOM tree. The traversal starts in sequential\n//! mode, and optionally parallelizes as it discovers work.\n\n#![deny(missing_docs)]\n\nuse crate::context::{PerThreadTraversalStatistics, StyleContext};\nuse crate::context::{ThreadLocalStyleContext, TraversalStatistics};\nuse crate::dom::{SendNode, TElement, TNode};\nuse crate::parallel;\nuse crate::scoped_tls::ScopedTLS;\nuse crate::traversal::{DomTraversal, PerLevelTraversalData, PreTraverseToken};\nuse std::collections::VecDeque;\nuse std::time::Instant;\n\n#[cfg(feature = \"servo\")]\nfn should_report_statistics() -> bool {\n false\n}\n\n#[cfg(feature = \"gecko\")]\nfn should_report_statistics() -> bool {\n unsafe { !crate::gecko_bindings::structs::ServoTraversalStatistics_sSingleton.is_null() }\n}\n\n#[cfg(feature = \"servo\")]\nfn report_statistics(_stats: &PerThreadTraversalStatistics) {\n unreachable!(\"Servo never report stats\");\n}\n\n#[cfg(feature = \"gecko\")]\nfn report_statistics(stats: &PerThreadTraversalStatistics) {\n // This should only be called in the main thread, or it may be racy\n // to update the statistics in a global variable.\n unsafe {\n debug_assert!(crate::gecko_bindings::bindings::Gecko_IsMainThread());\n let gecko_stats = crate::gecko_bindings::structs::ServoTraversalStatistics_sSingleton;\n (*gecko_stats).mElementsTraversed += stats.elements_traversed;\n (*gecko_stats).mElementsStyled += stats.elements_styled;\n (*gecko_stats).mElementsMatched += stats.elements_matched;\n (*gecko_stats).mStylesShared += stats.styles_shared;\n (*gecko_stats).mStylesReused += stats.styles_reused;\n }\n}\n\nfn with_pool_in_place_scope<'scope>(\n work_unit_max: usize,\n pool: Option<&rayon::ThreadPool>,\n closure: impl FnOnce(Option<&rayon::ScopeFifo<'scope>>) + Send + 'scope,\n) {\n if work_unit_max == 0 || pool.is_none() {\n closure(None);\n } else {\n let pool = pool.unwrap();\n pool.in_place_scope_fifo(|scope| {\n #[cfg(feature = \"gecko\")]\n debug_assert_eq!(\n pool.current_thread_index(),\n Some(0),\n \"Main thread should be the first thread\"\n );\n if cfg!(feature = \"gecko\") || pool.current_thread_index().is_some() {\n closure(Some(scope));\n } else {\n scope.spawn_fifo(|scope| closure(Some(scope)));\n }\n });\n }\n}\n\n/// See documentation of the pref for performance characteristics.\nfn work_unit_max() -> usize {\n static_prefs::pref!(\"layout.css.stylo-work-unit-size\") as usize\n}\n\n/// Do a DOM traversal for top-down and (optionally) bottom-up processing, generic over `D`.\n///\n/// We use an adaptive traversal strategy. We start out with simple sequential processing, until we\n/// arrive at a wide enough level in the DOM that the parallel traversal would parallelize it.\n/// If a thread pool is provided, we then transfer control over to the parallel traversal.\n///\n/// Returns true if the traversal was parallel, and also returns the statistics object containing\n/// information on nodes traversed (on nightly only). Not all of its fields will be initialized\n/// since we don't call finish().\npub fn traverse_dom(\n traversal: &D,\n token: PreTraverseToken,\n pool: Option<&rayon::ThreadPool>,\n) -> E\nwhere\n E: TElement,\n D: DomTraversal,\n{\n let root = token\n .traversal_root()\n .expect(\"Should've ensured we needed to traverse\");\n\n let report_stats = should_report_statistics();\n let dump_stats = traversal.shared_context().options.dump_style_statistics;\n let start_time = if dump_stats {\n Some(Instant::now())\n } else {\n None\n };\n\n // Declare the main-thread context, as well as the worker-thread contexts,\n // which we may or may not instantiate. It's important to declare the worker-\n // thread contexts first, so that they get dropped second. This matters because:\n // * ThreadLocalContexts borrow AtomicRefCells in TLS.\n // * Dropping a ThreadLocalContext can run SequentialTasks.\n // * Sequential tasks may call into functions like\n // Servo_StyleSet_GetBaseComputedValuesForElement, which instantiate a\n // ThreadLocalStyleContext on the main thread. If the main thread\n // ThreadLocalStyleContext has not released its TLS borrow by that point,\n // we'll panic on double-borrow.\n let mut scoped_tls = ScopedTLS::>::new(pool);\n // Process the nodes breadth-first. This helps keep similar traversal characteristics for the\n // style sharing cache.\n let work_unit_max = work_unit_max();\n\n let send_root = unsafe { SendNode::new(root.as_node()) };\n with_pool_in_place_scope(work_unit_max, pool, |maybe_scope| {\n let mut tlc = scoped_tls.ensure(parallel::create_thread_local_context);\n let mut context = StyleContext {\n shared: traversal.shared_context(),\n thread_local: &mut tlc,\n };\n\n let mut discovered = VecDeque::with_capacity(work_unit_max * 2);\n let current_dom_depth = send_root.depth();\n let opaque_root = send_root.opaque();\n discovered.push_back(send_root);\n parallel::style_trees(\n &mut context,\n discovered,\n opaque_root,\n work_unit_max,\n PerLevelTraversalData { current_dom_depth },\n maybe_scope,\n traversal,\n &scoped_tls,\n );\n });\n\n // Collect statistics from thread-locals if requested.\n if dump_stats || report_stats {\n let mut aggregate = PerThreadTraversalStatistics::default();\n for slot in scoped_tls.slots() {\n if let Some(cx) = slot.get_mut() {\n aggregate += cx.statistics.clone();\n }\n }\n\n if report_stats {\n report_statistics(&aggregate);\n }\n // dump statistics to stdout if requested\n if dump_stats {\n let parallel = pool.is_some();\n let stats =\n TraversalStatistics::new(aggregate, traversal, parallel, start_time.unwrap());\n if stats.is_large {\n println!(\"{}\", stats);\n }\n }\n }\n\n root\n}\n" }, { "path": "style/error_reporting.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! Types used to report parsing errors.\n\n#![deny(missing_docs)]\n\nuse crate::selector_parser::SelectorImpl;\nuse crate::stylesheets::UrlExtraData;\nuse cssparser::{BasicParseErrorKind, ParseErrorKind, SourceLocation, Token};\nuse selectors::parser::{Combinator, Component, RelativeSelector, Selector};\nuse selectors::visitor::{SelectorListKind, SelectorVisitor};\nuse selectors::SelectorList;\nuse std::fmt;\nuse style_traits::ParseError;\n\n/// Errors that can be encountered while parsing CSS.\n#[derive(Debug)]\npub enum ContextualParseError<'a> {\n /// A property declaration was not recognized.\n UnsupportedPropertyDeclaration(&'a str, ParseError<'a>, &'a [SelectorList]),\n /// A property descriptor was not recognized.\n UnsupportedPropertyDescriptor(&'a str, ParseError<'a>),\n /// A font face descriptor was not recognized.\n UnsupportedFontFaceDescriptor(&'a str, ParseError<'a>),\n /// A font feature values descriptor was not recognized.\n UnsupportedFontFeatureValuesDescriptor(&'a str, ParseError<'a>),\n /// A font palette values descriptor was not recognized.\n UnsupportedFontPaletteValuesDescriptor(&'a str, ParseError<'a>),\n /// A keyframe rule was not valid.\n InvalidKeyframeRule(&'a str, ParseError<'a>),\n /// A font feature values rule was not valid.\n InvalidFontFeatureValuesRule(&'a str, ParseError<'a>),\n /// A rule was invalid for some reason.\n InvalidRule(&'a str, ParseError<'a>),\n /// A rule was not recognized.\n UnsupportedRule(&'a str, ParseError<'a>),\n /// A viewport descriptor declaration was not recognized.\n UnsupportedViewportDescriptorDeclaration(&'a str, ParseError<'a>),\n /// A counter style descriptor declaration was not recognized.\n UnsupportedCounterStyleDescriptorDeclaration(&'a str, ParseError<'a>),\n /// A counter style rule had no symbols.\n InvalidCounterStyleWithoutSymbols(String),\n /// A counter style rule had less than two symbols.\n InvalidCounterStyleNotEnoughSymbols(String),\n /// A counter style rule did not have additive-symbols.\n InvalidCounterStyleWithoutAdditiveSymbols,\n /// A counter style rule had extends with symbols.\n InvalidCounterStyleExtendsWithSymbols,\n /// A counter style rule had extends with additive-symbols.\n InvalidCounterStyleExtendsWithAdditiveSymbols,\n /// A media rule was invalid for some reason.\n InvalidMediaRule(&'a str, ParseError<'a>),\n /// A value was not recognized.\n UnsupportedValue(&'a str, ParseError<'a>),\n /// A never-matching `:host` selector was found.\n NeverMatchingHostSelector(String),\n /// A view-transition declaration was not recognized.\n UnsupportedViewTransitionDescriptor(&'a str, ParseError<'a>),\n}\n\nimpl<'a> fmt::Display for ContextualParseError<'a> {\n fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n fn token_to_str(t: &Token, f: &mut fmt::Formatter) -> fmt::Result {\n match *t {\n Token::Ident(ref i) => write!(f, \"identifier {}\", i),\n Token::AtKeyword(ref kw) => write!(f, \"keyword @{}\", kw),\n Token::Hash(ref h) => write!(f, \"hash #{}\", h),\n Token::IDHash(ref h) => write!(f, \"id selector #{}\", h),\n Token::QuotedString(ref s) => write!(f, \"quoted string \\\"{}\\\"\", s),\n Token::UnquotedUrl(ref u) => write!(f, \"url {}\", u),\n Token::Delim(ref d) => write!(f, \"delimiter {}\", d),\n Token::Number {\n int_value: Some(i), ..\n } => write!(f, \"number {}\", i),\n Token::Number { value, .. } => write!(f, \"number {}\", value),\n Token::Percentage {\n int_value: Some(i), ..\n } => write!(f, \"percentage {}\", i),\n Token::Percentage { unit_value, .. } => {\n write!(f, \"percentage {}\", unit_value * 100.)\n },\n Token::Dimension {\n value, ref unit, ..\n } => write!(f, \"dimension {}{}\", value, unit),\n Token::WhiteSpace(_) => write!(f, \"whitespace\"),\n Token::Comment(_) => write!(f, \"comment\"),\n Token::Colon => write!(f, \"colon (:)\"),\n Token::Semicolon => write!(f, \"semicolon (;)\"),\n Token::Comma => write!(f, \"comma (,)\"),\n Token::IncludeMatch => write!(f, \"include match (~=)\"),\n Token::DashMatch => write!(f, \"dash match (|=)\"),\n Token::PrefixMatch => write!(f, \"prefix match (^=)\"),\n Token::SuffixMatch => write!(f, \"suffix match ($=)\"),\n Token::SubstringMatch => write!(f, \"substring match (*=)\"),\n Token::CDO => write!(f, \"CDO ()\"),\n Token::Function(ref name) => write!(f, \"function {}\", name),\n Token::ParenthesisBlock => write!(f, \"parenthesis (\"),\n Token::SquareBracketBlock => write!(f, \"square bracket [\"),\n Token::CurlyBracketBlock => write!(f, \"curly bracket {{\"),\n Token::BadUrl(ref _u) => write!(f, \"bad url parse error\"),\n Token::BadString(ref _s) => write!(f, \"bad string parse error\"),\n Token::CloseParenthesis => write!(f, \"unmatched close parenthesis\"),\n Token::CloseSquareBracket => write!(f, \"unmatched close square bracket\"),\n Token::CloseCurlyBracket => write!(f, \"unmatched close curly bracket\"),\n }\n }\n\n fn parse_error_to_str(err: &ParseError, f: &mut fmt::Formatter) -> fmt::Result {\n match err.kind {\n ParseErrorKind::Basic(BasicParseErrorKind::UnexpectedToken(ref t)) => {\n write!(f, \"found unexpected \")?;\n token_to_str(t, f)\n },\n ParseErrorKind::Basic(BasicParseErrorKind::EndOfInput) => {\n write!(f, \"unexpected end of input\")\n },\n ParseErrorKind::Basic(BasicParseErrorKind::AtRuleInvalid(ref i)) => {\n write!(f, \"@ rule invalid: {}\", i)\n },\n ParseErrorKind::Basic(BasicParseErrorKind::AtRuleBodyInvalid) => {\n write!(f, \"@ rule invalid\")\n },\n ParseErrorKind::Basic(BasicParseErrorKind::QualifiedRuleInvalid) => {\n write!(f, \"qualified rule invalid\")\n },\n ParseErrorKind::Custom(ref err) => write!(f, \"{:?}\", err),\n }\n }\n\n match *self {\n ContextualParseError::UnsupportedPropertyDeclaration(decl, ref err, _selectors) => {\n write!(f, \"Unsupported property declaration: '{}', \", decl)?;\n parse_error_to_str(err, f)\n },\n ContextualParseError::UnsupportedPropertyDescriptor(decl, ref err) => {\n write!(\n f,\n \"Unsupported @property descriptor declaration: '{}', \",\n decl\n )?;\n parse_error_to_str(err, f)\n },\n ContextualParseError::UnsupportedFontFaceDescriptor(decl, ref err) => {\n write!(\n f,\n \"Unsupported @font-face descriptor declaration: '{}', \",\n decl\n )?;\n parse_error_to_str(err, f)\n },\n ContextualParseError::UnsupportedFontFeatureValuesDescriptor(decl, ref err) => {\n write!(\n f,\n \"Unsupported @font-feature-values descriptor declaration: '{}', \",\n decl\n )?;\n parse_error_to_str(err, f)\n },\n ContextualParseError::UnsupportedFontPaletteValuesDescriptor(decl, ref err) => {\n write!(\n f,\n \"Unsupported @font-palette-values descriptor declaration: '{}', \",\n decl\n )?;\n parse_error_to_str(err, f)\n },\n ContextualParseError::InvalidKeyframeRule(rule, ref err) => {\n write!(f, \"Invalid keyframe rule: '{}', \", rule)?;\n parse_error_to_str(err, f)\n },\n ContextualParseError::InvalidFontFeatureValuesRule(rule, ref err) => {\n write!(f, \"Invalid font feature value rule: '{}', \", rule)?;\n parse_error_to_str(err, f)\n },\n ContextualParseError::InvalidRule(rule, ref err) => {\n write!(f, \"Invalid rule: '{}', \", rule)?;\n parse_error_to_str(err, f)\n },\n ContextualParseError::UnsupportedRule(rule, ref err) => {\n write!(f, \"Unsupported rule: '{}', \", rule)?;\n parse_error_to_str(err, f)\n },\n ContextualParseError::UnsupportedViewportDescriptorDeclaration(decl, ref err) => {\n write!(\n f,\n \"Unsupported @viewport descriptor declaration: '{}', \",\n decl\n )?;\n parse_error_to_str(err, f)\n },\n ContextualParseError::UnsupportedCounterStyleDescriptorDeclaration(decl, ref err) => {\n write!(\n f,\n \"Unsupported @counter-style descriptor declaration: '{}', \",\n decl\n )?;\n parse_error_to_str(err, f)\n },\n ContextualParseError::InvalidCounterStyleWithoutSymbols(ref system) => write!(\n f,\n \"Invalid @counter-style rule: 'system: {}' without 'symbols'\",\n system\n ),\n ContextualParseError::InvalidCounterStyleNotEnoughSymbols(ref system) => write!(\n f,\n \"Invalid @counter-style rule: 'system: {}' less than two 'symbols'\",\n system\n ),\n ContextualParseError::InvalidCounterStyleWithoutAdditiveSymbols => write!(\n f,\n \"Invalid @counter-style rule: 'system: additive' without 'additive-symbols'\"\n ),\n ContextualParseError::InvalidCounterStyleExtendsWithSymbols => write!(\n f,\n \"Invalid @counter-style rule: 'system: extends …' with 'symbols'\"\n ),\n ContextualParseError::InvalidCounterStyleExtendsWithAdditiveSymbols => write!(\n f,\n \"Invalid @counter-style rule: 'system: extends …' with 'additive-symbols'\"\n ),\n ContextualParseError::InvalidMediaRule(media_rule, ref err) => {\n write!(f, \"Invalid media rule: {}, \", media_rule)?;\n parse_error_to_str(err, f)\n },\n ContextualParseError::UnsupportedValue(_value, ref err) => parse_error_to_str(err, f),\n ContextualParseError::NeverMatchingHostSelector(ref selector) => {\n write!(f, \":host selector is not featureless: {}\", selector)\n },\n ContextualParseError::UnsupportedViewTransitionDescriptor(decl, ref err) => {\n write!(\n f,\n \"Unsupported @view-transition descriptor declaration: '{}', \",\n decl\n )?;\n parse_error_to_str(err, f)\n },\n }\n }\n}\n\n/// A generic trait for an error reporter.\npub trait ParseErrorReporter {\n /// Called when the style engine detects an error.\n ///\n /// Returns the current input being parsed, the source location it was\n /// reported from, and a message.\n fn report_error(\n &self,\n url: &UrlExtraData,\n location: SourceLocation,\n error: ContextualParseError,\n );\n}\n\n/// An error reporter that uses [the `log` crate](https://github.com/rust-lang-nursery/log)\n/// at `info` level.\n///\n/// This logging is silent by default, and can be enabled with a `RUST_LOG=style=info`\n/// environment variable.\n/// (See [`env_logger`](https://rust-lang-nursery.github.io/log/env_logger/).)\n#[cfg(feature = \"servo\")]\npub struct RustLogReporter;\n\n#[cfg(feature = \"servo\")]\nimpl ParseErrorReporter for RustLogReporter {\n fn report_error(\n &self,\n url: &UrlExtraData,\n location: SourceLocation,\n error: ContextualParseError,\n ) {\n if log_enabled!(log::Level::Info) {\n info!(\n \"Url:\\t{}\\n{}:{} {}\",\n url.as_str(),\n location.line,\n location.column,\n error\n )\n }\n }\n}\n\n/// Any warning a selector may generate.\n/// TODO(dshin): Bug 1860634 - Merge with never matching host selector warning, which is part of the rule parser.\n#[repr(u8)]\n#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]\npub enum SelectorWarningKind {\n /// Relative Selector with not enough constraint, either outside or inside the selector. e.g. `*:has(.a)`, `.a:has(*)`.\n /// May cause expensive invalidations for every element inserted and/or removed.\n UnconstraintedRelativeSelector,\n /// `:scope` can have 3 meanings, but in all cases, the relationship is defined strictly by an ancestor-descendant\n /// relationship. This means that any presence of sibling selectors to its right would make it never match.\n SiblingCombinatorAfterScopeSelector,\n}\n\nimpl SelectorWarningKind {\n /// Get all warnings for this selector.\n pub fn from_selector(selector: &Selector) -> Vec {\n let mut result = vec![];\n if UnconstrainedRelativeSelectorVisitor::has_warning(selector, 0, false) {\n result.push(SelectorWarningKind::UnconstraintedRelativeSelector);\n }\n if SiblingCombinatorAfterScopeSelectorVisitor::has_warning(selector) {\n result.push(SelectorWarningKind::SiblingCombinatorAfterScopeSelector);\n }\n result\n }\n}\n\n/// Per-compound state for finding unconstrained relative selectors.\nstruct PerCompoundState {\n /// Is there a relative selector in this compound?\n relative_selector_found: bool,\n /// Is this compound constrained in any way?\n constrained: bool,\n /// Nested below, or inside relative selector?\n in_relative_selector: bool,\n}\n\nimpl PerCompoundState {\n fn new(in_relative_selector: bool) -> Self {\n Self {\n relative_selector_found: false,\n constrained: false,\n in_relative_selector,\n }\n }\n}\n\n/// Visitor to check if there's any unconstrained relative selector.\nstruct UnconstrainedRelativeSelectorVisitor {\n compound_state: PerCompoundState,\n}\n\nimpl UnconstrainedRelativeSelectorVisitor {\n fn new(in_relative_selector: bool) -> Self {\n Self {\n compound_state: PerCompoundState::new(in_relative_selector),\n }\n }\n\n fn has_warning(\n selector: &Selector,\n offset: usize,\n in_relative_selector: bool,\n ) -> bool {\n let relative_selector = matches!(\n selector.iter_raw_parse_order_from(0).next().unwrap(),\n Component::RelativeSelectorAnchor\n );\n debug_assert!(\n !relative_selector || offset == 0,\n \"Checking relative selector from non-rightmost?\"\n );\n let mut visitor = Self::new(in_relative_selector);\n let mut iter = if relative_selector {\n selector.iter_skip_relative_selector_anchor()\n } else {\n selector.iter_from(offset)\n };\n loop {\n visitor.compound_state = PerCompoundState::new(in_relative_selector);\n\n for s in &mut iter {\n s.visit(&mut visitor);\n }\n\n if (visitor.compound_state.relative_selector_found\n || visitor.compound_state.in_relative_selector)\n && !visitor.compound_state.constrained\n {\n return true;\n }\n\n if iter.next_sequence().is_none() {\n break;\n }\n }\n false\n }\n}\n\nimpl SelectorVisitor for UnconstrainedRelativeSelectorVisitor {\n type Impl = SelectorImpl;\n\n fn visit_simple_selector(&mut self, c: &Component) -> bool {\n match c {\n // Deferred to visit_selector_list\n Component::Is(..)\n | Component::Where(..)\n | Component::Negation(..)\n | Component::Has(..) => (),\n Component::ExplicitUniversalType => (),\n _ => self.compound_state.constrained |= true,\n };\n true\n }\n\n fn visit_selector_list(\n &mut self,\n _list_kind: SelectorListKind,\n list: &[Selector],\n ) -> bool {\n let mut all_constrained = true;\n for s in list {\n let mut offset = 0;\n // First, check the rightmost compound for constraint at this level.\n if !self.compound_state.in_relative_selector {\n let mut nested = Self::new(false);\n let mut iter = s.iter();\n loop {\n for c in &mut iter {\n c.visit(&mut nested);\n offset += 1;\n }\n\n let c = iter.next_sequence();\n offset += 1;\n if c.map_or(true, |c| !c.is_pseudo_element()) {\n break;\n }\n }\n // Every single selector in the list must be constrained.\n all_constrained &= nested.compound_state.constrained;\n }\n\n if offset >= s.len() {\n continue;\n }\n\n // Then, recurse in to check at the deeper level.\n if Self::has_warning(s, offset, self.compound_state.in_relative_selector) {\n self.compound_state.constrained = false;\n if !self.compound_state.in_relative_selector {\n self.compound_state.relative_selector_found = true;\n }\n return false;\n }\n }\n self.compound_state.constrained |= all_constrained;\n true\n }\n\n fn visit_relative_selector_list(&mut self, list: &[RelativeSelector]) -> bool {\n debug_assert!(\n !self.compound_state.in_relative_selector,\n \"Nested relative selector\"\n );\n self.compound_state.relative_selector_found = true;\n\n for rs in list {\n // If the inside is unconstrained, we are unconstrained no matter what.\n if Self::has_warning(&rs.selector, 0, true) {\n self.compound_state.constrained = false;\n return false;\n }\n }\n true\n }\n}\n\nstruct SiblingCombinatorAfterScopeSelectorVisitor {\n right_combinator_is_sibling: bool,\n found: bool,\n}\n\nimpl SiblingCombinatorAfterScopeSelectorVisitor {\n fn new(right_combinator_is_sibling: bool) -> Self {\n Self {\n right_combinator_is_sibling,\n found: false,\n }\n }\n fn has_warning(selector: &Selector) -> bool {\n if !selector.has_scope_selector() {\n return false;\n }\n let visitor = SiblingCombinatorAfterScopeSelectorVisitor::new(false);\n visitor.find_never_matching_scope_selector(selector)\n }\n\n fn find_never_matching_scope_selector(mut self, selector: &Selector) -> bool {\n selector.visit(&mut self);\n self.found\n }\n}\n\nimpl SelectorVisitor for SiblingCombinatorAfterScopeSelectorVisitor {\n type Impl = SelectorImpl;\n\n fn visit_simple_selector(&mut self, c: &Component) -> bool {\n if !matches!(c, Component::Scope | Component::ImplicitScope) {\n return true;\n }\n // e.g. `:scope ~ .a` will never match.\n if self.right_combinator_is_sibling {\n self.found = true;\n }\n true\n }\n\n fn visit_selector_list(\n &mut self,\n _list_kind: SelectorListKind,\n list: &[Selector],\n ) -> bool {\n for s in list {\n let list_visitor = Self::new(self.right_combinator_is_sibling);\n self.found |= list_visitor.find_never_matching_scope_selector(s);\n }\n true\n }\n\n fn visit_complex_selector(&mut self, combinator_to_right: Option) -> bool {\n if let Some(c) = combinator_to_right {\n // Subject compounds' state is determined by the outer visitor. e.g: When there's `:is(.a .b) ~ .c`,\n // the inner visitor is assumed to be constructed with right_combinator_is_sibling == true.\n self.right_combinator_is_sibling = c.is_sibling();\n }\n true\n }\n\n // It's harder to discern if use of :scope is invalid - at least for now, defer.\n}\n" }, { "path": "style/font_face.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! The [`@font-face`][ff] at-rule.\n//!\n//! [ff]: https://drafts.csswg.org/css-fonts/#at-font-face-rule\n\nuse crate::derives::*;\nuse crate::error_reporting::ContextualParseError;\nuse crate::parser::{Parse, ParserContext};\nuse crate::shared_lock::{SharedRwLockReadGuard, ToCssWithGuard};\nuse crate::values::generics::font::FontStyle as GenericFontStyle;\nuse crate::values::specified::{url::SpecifiedUrl, Angle};\nuse cssparser::{Parser, RuleBodyParser, SourceLocation};\nuse std::fmt::{self, Write};\nuse style_traits::{CssStringWriter, CssWriter, ParseError, StyleParseErrorKind, ToCss};\n\npub use crate::properties::font_face::{DescriptorId, DescriptorParser, Descriptors};\npub use crate::values::computed::font::{FamilyName, FontStretch};\npub use crate::values::specified::font::{\n AbsoluteFontWeight, FontFeatureSettings, FontLanguageOverride,\n FontStretch as SpecifiedFontStretch, FontVariationSettings, MetricsOverride,\n SpecifiedFontStyle,\n};\n\n/// A source for a font-face rule.\n#[cfg_attr(feature = \"servo\", derive(Deserialize, Serialize))]\n#[derive(Clone, Debug, Eq, MallocSizeOf, PartialEq, ToCss, ToShmem)]\npub enum Source {\n /// A `url()` source.\n Url(UrlSource),\n /// A `local()` source.\n #[css(function)]\n Local(FamilyName),\n}\n\n/// A list of sources for the font-face src descriptor.\n#[derive(Clone, Debug, Eq, MallocSizeOf, PartialEq, ToCss, ToShmem)]\n#[css(comma)]\npub struct SourceList(#[css(iterable)] pub Vec);\n\n// We can't just use OneOrMoreSeparated to derive Parse for the Source list,\n// because we want to filter out components that parsed as None, then fail if no\n// valid components remain. So we provide our own implementation here.\nimpl Parse for SourceList {\n fn parse<'i, 't>(\n context: &ParserContext,\n input: &mut Parser<'i, 't>,\n ) -> Result> {\n // Parse the comma-separated list, then let filter_map discard any None items.\n let list = input\n .parse_comma_separated(|input| {\n let s = input.parse_entirely(|input| Source::parse(context, input));\n while input.next().is_ok() {}\n Ok(s.ok())\n })?\n .into_iter()\n .filter_map(|s| s)\n .collect::>();\n if list.is_empty() {\n Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError))\n } else {\n Ok(SourceList(list))\n }\n }\n}\n\n/// Keywords for the font-face src descriptor's format() function.\n/// ('None' and 'Unknown' are for internal use in gfx, not exposed to CSS.)\n#[derive(Clone, Copy, Debug, Eq, MallocSizeOf, Parse, PartialEq, ToCss, ToShmem)]\n#[cfg_attr(feature = \"servo\", derive(Deserialize, Serialize))]\n#[repr(u8)]\n#[allow(missing_docs)]\npub enum FontFaceSourceFormatKeyword {\n #[css(skip)]\n None,\n Collection,\n EmbeddedOpentype,\n Opentype,\n Svg,\n Truetype,\n Woff,\n Woff2,\n #[css(skip)]\n Unknown,\n}\n\n/// Flags for the @font-face tech() function, indicating font technologies\n/// required by the resource.\n#[derive(Clone, Copy, Debug, Eq, MallocSizeOf, PartialEq, ToShmem)]\n#[cfg_attr(feature = \"servo\", derive(Deserialize, Serialize))]\n#[repr(C)]\npub struct FontFaceSourceTechFlags(u16);\nbitflags! {\n impl FontFaceSourceTechFlags: u16 {\n /// Font requires OpenType feature support.\n const FEATURES_OPENTYPE = 1 << 0;\n /// Font requires Apple Advanced Typography support.\n const FEATURES_AAT = 1 << 1;\n /// Font requires Graphite shaping support.\n const FEATURES_GRAPHITE = 1 << 2;\n /// Font requires COLRv0 rendering support (simple list of colored layers).\n const COLOR_COLRV0 = 1 << 3;\n /// Font requires COLRv1 rendering support (graph of paint operations).\n const COLOR_COLRV1 = 1 << 4;\n /// Font requires SVG glyph rendering support.\n const COLOR_SVG = 1 << 5;\n /// Font has bitmap glyphs in 'sbix' format.\n const COLOR_SBIX = 1 << 6;\n /// Font has bitmap glyphs in 'CBDT' format.\n const COLOR_CBDT = 1 << 7;\n /// Font requires OpenType Variations support.\n const VARIATIONS = 1 << 8;\n /// Font requires CPAL palette selection support.\n const PALETTES = 1 << 9;\n /// Font requires support for incremental downloading.\n const INCREMENTAL = 1 << 10;\n }\n}\n\nimpl FontFaceSourceTechFlags {\n /// Parse a single font-technology keyword and return its flag.\n pub fn parse_one<'i, 't>(input: &mut Parser<'i, 't>) -> Result> {\n Ok(try_match_ident_ignore_ascii_case! { input,\n \"features-opentype\" => Self::FEATURES_OPENTYPE,\n \"features-aat\" => Self::FEATURES_AAT,\n \"features-graphite\" => Self::FEATURES_GRAPHITE,\n \"color-colrv0\" => Self::COLOR_COLRV0,\n \"color-colrv1\" => Self::COLOR_COLRV1,\n \"color-svg\" => Self::COLOR_SVG,\n \"color-sbix\" => Self::COLOR_SBIX,\n \"color-cbdt\" => Self::COLOR_CBDT,\n \"variations\" => Self::VARIATIONS,\n \"palettes\" => Self::PALETTES,\n \"incremental\" => Self::INCREMENTAL,\n })\n }\n}\n\nimpl Parse for FontFaceSourceTechFlags {\n fn parse<'i, 't>(\n _context: &ParserContext,\n input: &mut Parser<'i, 't>,\n ) -> Result> {\n let location = input.current_source_location();\n // We don't actually care about the return value of parse_comma_separated,\n // because we insert the flags into result as we go.\n let mut result = Self::empty();\n input.parse_comma_separated(|input| {\n let flag = Self::parse_one(input)?;\n result.insert(flag);\n Ok(())\n })?;\n if !result.is_empty() {\n Ok(result)\n } else {\n Err(location.new_custom_error(StyleParseErrorKind::UnspecifiedError))\n }\n }\n}\n\n#[allow(unused_assignments)]\nimpl ToCss for FontFaceSourceTechFlags {\n fn to_css(&self, dest: &mut CssWriter) -> fmt::Result\n where\n W: fmt::Write,\n {\n let mut first = true;\n\n macro_rules! write_if_flag {\n ($s:expr => $f:ident) => {\n if self.contains(Self::$f) {\n if first {\n first = false;\n } else {\n dest.write_str(\", \")?;\n }\n dest.write_str($s)?;\n }\n };\n }\n\n write_if_flag!(\"features-opentype\" => FEATURES_OPENTYPE);\n write_if_flag!(\"features-aat\" => FEATURES_AAT);\n write_if_flag!(\"features-graphite\" => FEATURES_GRAPHITE);\n write_if_flag!(\"color-colrv0\" => COLOR_COLRV0);\n write_if_flag!(\"color-colrv1\" => COLOR_COLRV1);\n write_if_flag!(\"color-svg\" => COLOR_SVG);\n write_if_flag!(\"color-sbix\" => COLOR_SBIX);\n write_if_flag!(\"color-cbdt\" => COLOR_CBDT);\n write_if_flag!(\"variations\" => VARIATIONS);\n write_if_flag!(\"palettes\" => PALETTES);\n write_if_flag!(\"incremental\" => INCREMENTAL);\n\n Ok(())\n }\n}\n\n/// \n#[derive(Clone, Debug, ToShmem, PartialEq)]\npub struct FontFaceRule {\n /// The descriptors of the @font-face rule.\n pub descriptors: Descriptors,\n /// The parser location of the rule.\n pub source_location: SourceLocation,\n}\n\nimpl FontFaceRule {\n /// Returns an empty rule.\n pub fn empty(source_location: SourceLocation) -> Self {\n Self {\n descriptors: Default::default(),\n source_location,\n }\n }\n}\n\n/// A POD representation for Gecko. All pointers here are non-owned and as such\n/// can't outlive the rule they came from, but we can't enforce that via C++.\n///\n/// All the strings are of course utf8.\n#[cfg(feature = \"gecko\")]\n#[derive(Clone, Copy, Debug, Eq, PartialEq)]\n#[repr(u8)]\n#[allow(missing_docs)]\npub enum FontFaceSourceListComponent {\n Url(*const crate::gecko::url::CssUrl),\n Local(*mut crate::gecko_bindings::structs::nsAtom),\n FormatHintKeyword(FontFaceSourceFormatKeyword),\n FormatHintString {\n length: usize,\n utf8_bytes: *const u8,\n },\n TechFlags(FontFaceSourceTechFlags),\n}\n\n#[derive(Clone, Debug, Eq, MallocSizeOf, PartialEq, ToCss, ToShmem)]\n#[cfg_attr(feature = \"servo\", derive(Deserialize, Serialize))]\n#[repr(u8)]\n#[allow(missing_docs)]\npub enum FontFaceSourceFormat {\n Keyword(FontFaceSourceFormatKeyword),\n String(String),\n}\n\n/// A `UrlSource` represents a font-face source that has been specified with a\n/// `url()` function.\n///\n/// \n#[cfg_attr(feature = \"servo\", derive(Deserialize, Serialize))]\n#[derive(Clone, Debug, Eq, MallocSizeOf, PartialEq, ToShmem)]\npub struct UrlSource {\n /// The specified url.\n pub url: SpecifiedUrl,\n /// The format hint specified with the `format()` function, if present.\n pub format_hint: Option,\n /// The font technology flags specified with the `tech()` function, if any.\n pub tech_flags: FontFaceSourceTechFlags,\n}\n\nimpl ToCss for UrlSource {\n fn to_css(&self, dest: &mut CssWriter) -> fmt::Result\n where\n W: fmt::Write,\n {\n self.url.to_css(dest)?;\n if let Some(hint) = &self.format_hint {\n dest.write_str(\" format(\")?;\n hint.to_css(dest)?;\n dest.write_char(')')?;\n }\n if !self.tech_flags.is_empty() {\n dest.write_str(\" tech(\")?;\n self.tech_flags.to_css(dest)?;\n dest.write_char(')')?;\n }\n Ok(())\n }\n}\n\n/// A font-display value for a @font-face rule.\n/// The font-display descriptor determines how a font face is displayed based\n/// on whether and when it is downloaded and ready to use.\n#[allow(missing_docs)]\n#[cfg_attr(feature = \"servo\", derive(Deserialize, Serialize))]\n#[derive(\n Clone, Copy, Debug, Eq, MallocSizeOf, Parse, PartialEq, ToComputedValue, ToCss, ToShmem,\n)]\n#[repr(u8)]\npub enum FontDisplay {\n Auto,\n Block,\n Swap,\n Fallback,\n Optional,\n}\n\nmacro_rules! impl_range {\n ($range:ident, $component:ident) => {\n impl Parse for $range {\n fn parse<'i, 't>(\n context: &ParserContext,\n input: &mut Parser<'i, 't>,\n ) -> Result> {\n let first = $component::parse(context, input)?;\n let second = input\n .try_parse(|input| $component::parse(context, input))\n .unwrap_or_else(|_| first.clone());\n Ok($range(first, second))\n }\n }\n impl ToCss for $range {\n fn to_css(&self, dest: &mut CssWriter) -> fmt::Result\n where\n W: fmt::Write,\n {\n self.0.to_css(dest)?;\n if self.0 != self.1 {\n dest.write_char(' ')?;\n self.1.to_css(dest)?;\n }\n Ok(())\n }\n }\n };\n}\n\n/// The font-weight descriptor:\n///\n/// https://drafts.csswg.org/css-fonts-4/#descdef-font-face-font-weight\n#[derive(Clone, Debug, MallocSizeOf, PartialEq, ToShmem)]\npub struct FontWeightRange(pub AbsoluteFontWeight, pub AbsoluteFontWeight);\nimpl_range!(FontWeightRange, AbsoluteFontWeight);\n\n/// The computed representation of the above so Gecko can read them easily.\n///\n/// This one is needed because cbindgen doesn't know how to generate\n/// specified::Number.\n#[repr(C)]\n#[allow(missing_docs)]\npub struct ComputedFontWeightRange(f32, f32);\n\n#[inline]\nfn sort_range(a: T, b: T) -> (T, T) {\n if a > b {\n (b, a)\n } else {\n (a, b)\n }\n}\n\nimpl FontWeightRange {\n /// Returns a computed font-stretch range.\n pub fn compute(&self) -> ComputedFontWeightRange {\n let (min, max) = sort_range(self.0.compute().value(), self.1.compute().value());\n ComputedFontWeightRange(min, max)\n }\n}\n\n/// The font-stretch descriptor:\n///\n/// https://drafts.csswg.org/css-fonts-4/#descdef-font-face-font-stretch\n#[derive(Clone, Debug, MallocSizeOf, PartialEq, ToShmem)]\npub struct FontStretchRange(pub SpecifiedFontStretch, pub SpecifiedFontStretch);\nimpl_range!(FontStretchRange, SpecifiedFontStretch);\n\n/// The computed representation of the above, so that Gecko can read them\n/// easily.\n#[repr(C)]\n#[allow(missing_docs)]\npub struct ComputedFontStretchRange(FontStretch, FontStretch);\n\nimpl FontStretchRange {\n /// Returns a computed font-stretch range.\n pub fn compute(&self) -> ComputedFontStretchRange {\n fn compute_stretch(s: &SpecifiedFontStretch) -> FontStretch {\n match *s {\n SpecifiedFontStretch::Keyword(ref kw) => kw.compute(),\n SpecifiedFontStretch::Stretch(ref p) => FontStretch::from_percentage(p.0.get()),\n SpecifiedFontStretch::System(..) => unreachable!(),\n }\n }\n\n let (min, max) = sort_range(compute_stretch(&self.0), compute_stretch(&self.1));\n ComputedFontStretchRange(min, max)\n }\n}\n\n/// The font-style descriptor:\n///\n/// https://drafts.csswg.org/css-fonts-4/#descdef-font-face-font-style\n#[derive(Clone, Debug, MallocSizeOf, PartialEq, ToShmem)]\n#[allow(missing_docs)]\npub enum FontStyle {\n Italic,\n Oblique(Angle, Angle),\n}\n\n/// The computed representation of the above, with angles in degrees, so that\n/// Gecko can read them easily.\n#[repr(u8)]\n#[allow(missing_docs)]\npub enum ComputedFontStyleDescriptor {\n Italic,\n Oblique(f32, f32),\n}\n\nimpl Parse for FontStyle {\n fn parse<'i, 't>(\n context: &ParserContext,\n input: &mut Parser<'i, 't>,\n ) -> Result> {\n // We parse 'normal' explicitly here to distinguish it from 'oblique 0deg',\n // because we must not accept a following angle.\n if input\n .try_parse(|i| i.expect_ident_matching(\"normal\"))\n .is_ok()\n {\n return Ok(FontStyle::Oblique(Angle::zero(), Angle::zero()));\n }\n\n let style = SpecifiedFontStyle::parse(context, input)?;\n Ok(match style {\n GenericFontStyle::Italic => FontStyle::Italic,\n GenericFontStyle::Oblique(angle) => {\n let second_angle = input\n .try_parse(|input| SpecifiedFontStyle::parse_angle(context, input))\n .unwrap_or_else(|_| angle.clone());\n\n FontStyle::Oblique(angle, second_angle)\n },\n })\n }\n}\n\nimpl ToCss for FontStyle {\n fn to_css(&self, dest: &mut CssWriter) -> fmt::Result\n where\n W: fmt::Write,\n {\n match *self {\n FontStyle::Italic => dest.write_str(\"italic\"),\n FontStyle::Oblique(ref first, ref second) => {\n // Not first.is_zero() because we don't want to serialize\n // `oblique calc(0deg)` as `normal`.\n if *first == Angle::zero() && first == second {\n return dest.write_str(\"normal\");\n }\n dest.write_str(\"oblique\")?;\n if *first != SpecifiedFontStyle::default_angle() || first != second {\n dest.write_char(' ')?;\n first.to_css(dest)?;\n }\n if first != second {\n dest.write_char(' ')?;\n second.to_css(dest)?;\n }\n Ok(())\n },\n }\n }\n}\n\nimpl FontStyle {\n /// Returns a computed font-style descriptor.\n pub fn compute(&self) -> ComputedFontStyleDescriptor {\n match *self {\n FontStyle::Italic => ComputedFontStyleDescriptor::Italic,\n FontStyle::Oblique(ref first, ref second) => {\n let (min, max) = sort_range(\n SpecifiedFontStyle::compute_angle_degrees(first),\n SpecifiedFontStyle::compute_angle_degrees(second),\n );\n ComputedFontStyleDescriptor::Oblique(min, max)\n },\n }\n }\n}\n\n/// Parse the block inside a `@font-face` rule.\n///\n/// Note that the prelude parsing code lives in the `stylesheets` module.\npub fn parse_font_face_block(\n context: &ParserContext,\n input: &mut Parser,\n source_location: SourceLocation,\n) -> FontFaceRule {\n let mut rule = FontFaceRule::empty(source_location);\n {\n let mut parser = DescriptorParser {\n context,\n descriptors: &mut rule.descriptors,\n };\n let mut iter = RuleBodyParser::new(input, &mut parser);\n while let Some(declaration) = iter.next() {\n if let Err((error, slice)) = declaration {\n let location = error.location;\n let error = ContextualParseError::UnsupportedFontFaceDescriptor(slice, error);\n context.log_css_error(location, error)\n }\n }\n }\n rule\n}\n\n\nimpl Parse for Source {\n fn parse<'i, 't>(\n context: &ParserContext,\n input: &mut Parser<'i, 't>,\n ) -> Result> {\n if input\n .try_parse(|input| input.expect_function_matching(\"local\"))\n .is_ok()\n {\n return input\n .parse_nested_block(|input| FamilyName::parse(context, input))\n .map(Source::Local);\n }\n\n let url = SpecifiedUrl::parse(context, input)?;\n\n // Parsing optional format()\n let format_hint = if input\n .try_parse(|input| input.expect_function_matching(\"format\"))\n .is_ok()\n {\n input.parse_nested_block(|input| {\n if let Ok(kw) = input.try_parse(FontFaceSourceFormatKeyword::parse) {\n Ok(Some(FontFaceSourceFormat::Keyword(kw)))\n } else {\n let s = input.expect_string()?.as_ref().to_owned();\n Ok(Some(FontFaceSourceFormat::String(s)))\n }\n })?\n } else {\n None\n };\n\n // Parse optional tech()\n let tech_flags = if static_prefs::pref!(\"layout.css.font-tech.enabled\")\n && input\n .try_parse(|input| input.expect_function_matching(\"tech\"))\n .is_ok()\n {\n input.parse_nested_block(|input| FontFaceSourceTechFlags::parse(context, input))?\n } else {\n FontFaceSourceTechFlags::empty()\n };\n\n Ok(Source::Url(UrlSource {\n url,\n format_hint,\n tech_flags,\n }))\n }\n}\n\nimpl ToCssWithGuard for FontFaceRule {\n // Serialization of FontFaceRule is not specced.\n fn to_css(&self, _guard: &SharedRwLockReadGuard, dest: &mut CssStringWriter) -> fmt::Result {\n dest.write_str(\"@font-face { \")?;\n self.descriptors.to_css(&mut CssWriter::new(dest))?;\n dest.write_char('}')\n }\n}\n" }, { "path": "style/font_metrics.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! Access to font metrics from the style system.\n\n#![deny(missing_docs)]\n\nuse crate::values::computed::Length;\n\n/// Represents the font metrics that style needs from a font to compute the\n/// value of certain CSS units like `ex`.\n#[derive(Clone, Debug, PartialEq)]\npub struct FontMetrics {\n /// The x-height of the font.\n pub x_height: Option,\n /// The zero advance. This is usually writing mode dependent\n pub zero_advance_measure: Option,\n /// The cap-height of the font.\n pub cap_height: Option,\n /// The ideographic-width of the font.\n pub ic_width: Option,\n /// The ascent of the font (a value is always available for this).\n pub ascent: Length,\n /// Script scale down factor for math-depth 1.\n /// https://w3c.github.io/mathml-core/#dfn-scriptpercentscaledown\n pub script_percent_scale_down: Option,\n /// Script scale down factor for math-depth 2.\n /// https://w3c.github.io/mathml-core/#dfn-scriptscriptpercentscaledown\n pub script_script_percent_scale_down: Option,\n}\n\nimpl Default for FontMetrics {\n fn default() -> Self {\n FontMetrics {\n x_height: None,\n zero_advance_measure: None,\n cap_height: None,\n ic_width: None,\n ascent: Length::new(0.0),\n script_percent_scale_down: None,\n script_script_percent_scale_down: None,\n }\n }\n}\n\nimpl FontMetrics {\n /// Returns the x-height, computing a fallback value if not present\n pub fn x_height_or_default(&self, reference_font_size: Length) -> Length {\n // https://drafts.csswg.org/css-values/#ex\n //\n // In the cases where it is impossible or impractical to\n // determine the x-height, a value of 0.5em must be\n // assumed.\n //\n // (But note we use 0.5em of the used, not computed\n // font-size)\n self.x_height.unwrap_or_else(|| reference_font_size * 0.5)\n }\n\n /// Returns the zero advance measure, computing a fallback value if not present\n pub fn zero_advance_measure_or_default(\n &self,\n reference_font_size: Length,\n upright: bool,\n ) -> Length {\n // https://drafts.csswg.org/css-values/#ch\n //\n // In the cases where it is impossible or impractical to\n // determine the measure of the “0” glyph, it must be\n // assumed to be 0.5em wide by 1em tall. Thus, the ch\n // unit falls back to 0.5em in the general case, and to\n // 1em when it would be typeset upright (i.e.\n // writing-mode is vertical-rl or vertical-lr and\n // text-orientation is upright).\n //\n // Same caveat about computed vs. used font-size applies\n // above.\n self.zero_advance_measure.unwrap_or_else(|| {\n if upright {\n reference_font_size\n } else {\n reference_font_size * 0.5\n }\n })\n }\n\n /// Returns the cap-height, computing a fallback value if not present\n pub fn cap_height_or_default(&self) -> Length {\n // https://drafts.csswg.org/css-values/#cap\n //\n // In the cases where it is impossible or impractical to\n // determine the cap-height, the font’s ascent must be\n // used.\n //\n self.cap_height.unwrap_or_else(|| self.ascent)\n }\n\n /// Returns the ideographic advance measure, computing a fallback value if not present\n pub fn ic_width_or_default(&self, reference_font_size: Length) -> Length {\n // https://drafts.csswg.org/css-values/#ic\n //\n // In the cases where it is impossible or impractical to\n // determine the ideographic advance measure, it must be\n // assumed to be 1em.\n //\n // Same caveat about computed vs. used as for other\n // metric-dependent units.\n self.ic_width.unwrap_or_else(|| reference_font_size)\n }\n}\n\n/// Type of font metrics to retrieve.\n#[derive(Clone, Debug, PartialEq)]\npub enum FontMetricsOrientation {\n /// Get metrics for horizontal or vertical according to the Context's\n /// writing mode, using horizontal metrics for vertical/mixed\n MatchContextPreferHorizontal,\n /// Get metrics for horizontal or vertical according to the Context's\n /// writing mode, using vertical metrics for vertical/mixed\n MatchContextPreferVertical,\n /// Force getting horizontal metrics.\n Horizontal,\n}\n" }, { "path": "style/gecko/anon_boxes.toml", "content": "# This Source Code Form is subject to the terms of the Mozilla Public\n# License, v. 2.0. If a copy of the MPL was not distributed with this\n# file, You can obtain one at http://mozilla.org/MPL/2.0/.\n\n# This file contains the list of anonymous boxes and some flags, much like\n# longhands.toml and pseudo_elements.toml.\n#\n# Each anon box has its own section, with the following keys:\n# inherits - whether the anon box inherits from its parent or not. Defaults to true.\n# wrapper - whether the anon box is a wrapper around other frames during\n# frame tree fix-up (e.g. table anonymous boxes, ruby anonymous boxes, anonymous\n# flex item blocks, etc). Defaults to false.\n#\n# When adding an anon box, you also need to add the relevant atom to\n# StaticAtoms.py, with the camel-case name of the anon box, in the same order as\n# this file.\n\n[-moz-oof-placeholder]\ninherits = false\n# Framesets\n[-moz-hframeset-border]\ninherits = false\n[-moz-vframeset-border]\ninherits = false\n[-moz-frameset-blank]\ninherits = false\n\n# Table\n[-moz-table-column-group]\ninherits = false\n[-moz-table-column]\ninherits = false\n\n[-moz-page]\ninherits = false\n[-moz-page-break]\ninherits = false\n[-moz-page-content]\ninherits = false\n[-moz-printed-sheet]\ninherits = false\n\n# Applies to blocks that wrap contiguous runs of \"column-span: all\" elements in\n# multi-column subtrees, or the wrappers themselves, all the way up to the\n# column set wrappers.\n[-moz-column-span-wrapper]\ninherits = false\n\n# ::-moz-text, ::-moz-oof-placeholder, and ::-moz-first-letter-continuation are\n# non-elements which no rule will match.\n[-moz-text]\n# nsFirstLetterFrames for content outside the ::first-letter.\n[-moz-first-letter-continuation]\n\n[-moz-block-inside-inline-wrapper]\n[-moz-mathml-anonymous-block]\nwrapper = true\n[-moz-line-frame]\n\n[-moz-cell-content]\n[-moz-fieldset-content]\n[-moz-html-canvas-content]\n\n[-moz-inline-table]\nwrapper = true\n[-moz-table]\nwrapper = true\n[-moz-table-cell]\nwrapper = true\n[-moz-table-wrapper]\n[-moz-table-row-group]\nwrapper = true\n[-moz-table-row]\nwrapper = true\n\n[-moz-canvas]\ninherits = false\n[-moz-page-sequence]\n[-moz-scrolled-content]\n\n# A column set is a set of columns inside of ColumnSetWrapperFrame, which\n# applies to nsColumnSetFrame. It doesn't contain any column-span elements.\n[-moz-column-set]\n[-moz-column-content]\n\n# The root (viewport) frame\n[-moz-viewport]\ninherits = false\n# The root scrollframe.\n[-moz-viewport-scroll]\ninherits = false\n\n# Inside a flex/grid/-moz-box container, a contiguous run of text gets wrapped\n# in an anonymous block, which is then treated as a flex item.\n[-moz-anonymous-item]\nwrapper = true\n\n[-moz-block-ruby-content]\n[-moz-ruby]\nwrapper = true\n[-moz-ruby-base]\nwrapper = true\n[-moz-ruby-base-container]\nwrapper = true\n[-moz-ruby-text]\nwrapper = true\n[-moz-ruby-text-container]\nwrapper = true\n\n[-moz-svg-marker-anon-child]\n[-moz-svg-outer-svg-anon-child]\n[-moz-svg-foreign-content]\n[-moz-svg-text]\n" }, { "path": "style/gecko/arc_types.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! This file lists all arc FFI types and defines corresponding addref and release functions. This\n//! list loosely corresponds to ServoLockedArcTypeList.inc file in Gecko.\n\n#![allow(non_snake_case, missing_docs)]\n\nuse crate::gecko::url::CssUrlData;\nuse crate::media_queries::MediaList;\nuse crate::properties::animated_properties::AnimationValue;\nuse crate::properties::{ComputedValues, PropertyDeclarationBlock};\nuse crate::shared_lock::Locked;\nuse crate::stylesheets::keyframes_rule::Keyframe;\nuse crate::stylesheets::{\n AppearanceBaseRule, ContainerRule, CssRules, CustomMediaRule, DocumentRule,\n FontFeatureValuesRule, FontPaletteValuesRule, LayerBlockRule, LayerStatementRule, MarginRule,\n MediaRule, NamespaceRule, PropertyRule, ScopeRule, StartingStyleRule, StylesheetContents,\n SupportsRule, ViewTransitionRule,\n};\npub use crate::stylesheets::{\n LockedCounterStyleRule, LockedFontFaceRule, LockedImportRule, LockedKeyframesRule,\n LockedNestedDeclarationsRule, LockedPageRule, LockedPositionTryRule, LockedStyleRule,\n};\nuse servo_arc::Arc;\n\nmacro_rules! impl_simple_arc_ffi {\n ($ty:ty, $addref:ident, $release:ident) => {\n #[no_mangle]\n pub unsafe extern \"C\" fn $addref(obj: *const $ty) {\n std::mem::forget(Arc::from_raw_addrefed(obj));\n }\n\n #[no_mangle]\n pub unsafe extern \"C\" fn $release(obj: *const $ty) {\n let _ = Arc::from_raw(obj);\n }\n };\n}\n\nmacro_rules! impl_locked_arc_ffi {\n ($servo_type:ty, $alias:ident, $addref:ident, $release:ident) => {\n /// A simple alias for a locked type.\n pub type $alias = Locked<$servo_type>;\n impl_simple_arc_ffi!($alias, $addref, $release);\n };\n}\n\nimpl_locked_arc_ffi!(\n CssRules,\n LockedCssRules,\n Servo_CssRules_AddRef,\n Servo_CssRules_Release\n);\nimpl_locked_arc_ffi!(\n PropertyDeclarationBlock,\n LockedDeclarationBlock,\n Servo_DeclarationBlock_AddRef,\n Servo_DeclarationBlock_Release\n);\nimpl_simple_arc_ffi!(\n LockedStyleRule,\n Servo_StyleRule_AddRef,\n Servo_StyleRule_Release\n);\nimpl_simple_arc_ffi!(\n LockedImportRule,\n Servo_ImportRule_AddRef,\n Servo_ImportRule_Release\n);\nimpl_locked_arc_ffi!(\n Keyframe,\n LockedKeyframe,\n Servo_Keyframe_AddRef,\n Servo_Keyframe_Release\n);\nimpl_simple_arc_ffi!(\n LockedKeyframesRule,\n Servo_KeyframesRule_AddRef,\n Servo_KeyframesRule_Release\n);\nimpl_simple_arc_ffi!(\n LayerBlockRule,\n Servo_LayerBlockRule_AddRef,\n Servo_LayerBlockRule_Release\n);\nimpl_simple_arc_ffi!(\n LayerStatementRule,\n Servo_LayerStatementRule_AddRef,\n Servo_LayerStatementRule_Release\n);\nimpl_locked_arc_ffi!(\n MediaList,\n LockedMediaList,\n Servo_MediaList_AddRef,\n Servo_MediaList_Release\n);\nimpl_simple_arc_ffi!(MediaRule, Servo_MediaRule_AddRef, Servo_MediaRule_Release);\nimpl_simple_arc_ffi!(\n CustomMediaRule,\n Servo_CustomMediaRule_AddRef,\n Servo_CustomMediaRule_Release\n);\nimpl_simple_arc_ffi!(\n NamespaceRule,\n Servo_NamespaceRule_AddRef,\n Servo_NamespaceRule_Release\n);\nimpl_simple_arc_ffi!(\n MarginRule,\n Servo_MarginRule_AddRef,\n Servo_MarginRule_Release\n);\nimpl_simple_arc_ffi!(\n LockedPageRule,\n Servo_PageRule_AddRef,\n Servo_PageRule_Release\n);\nimpl_simple_arc_ffi!(\n PropertyRule,\n Servo_PropertyRule_AddRef,\n Servo_PropertyRule_Release\n);\nimpl_simple_arc_ffi!(\n SupportsRule,\n Servo_SupportsRule_AddRef,\n Servo_SupportsRule_Release\n);\nimpl_simple_arc_ffi!(\n ContainerRule,\n Servo_ContainerRule_AddRef,\n Servo_ContainerRule_Release\n);\nimpl_simple_arc_ffi!(\n DocumentRule,\n Servo_DocumentRule_AddRef,\n Servo_DocumentRule_Release\n);\nimpl_simple_arc_ffi!(\n FontFeatureValuesRule,\n Servo_FontFeatureValuesRule_AddRef,\n Servo_FontFeatureValuesRule_Release\n);\nimpl_simple_arc_ffi!(\n FontPaletteValuesRule,\n Servo_FontPaletteValuesRule_AddRef,\n Servo_FontPaletteValuesRule_Release\n);\nimpl_simple_arc_ffi!(\n LockedFontFaceRule,\n Servo_FontFaceRule_AddRef,\n Servo_FontFaceRule_Release\n);\nimpl_simple_arc_ffi!(\n LockedCounterStyleRule,\n Servo_CounterStyleRule_AddRef,\n Servo_CounterStyleRule_Release\n);\n\nimpl_simple_arc_ffi!(\n StylesheetContents,\n Servo_StyleSheetContents_AddRef,\n Servo_StyleSheetContents_Release\n);\nimpl_simple_arc_ffi!(\n CssUrlData,\n Servo_CssUrlData_AddRef,\n Servo_CssUrlData_Release\n);\nimpl_simple_arc_ffi!(\n ComputedValues,\n Servo_ComputedStyle_AddRef,\n Servo_ComputedStyle_Release\n);\nimpl_simple_arc_ffi!(\n AnimationValue,\n Servo_AnimationValue_AddRef,\n Servo_AnimationValue_Release\n);\nimpl_simple_arc_ffi!(ScopeRule, Servo_ScopeRule_AddRef, Servo_ScopeRule_Release);\nimpl_simple_arc_ffi!(\n StartingStyleRule,\n Servo_StartingStyleRule_AddRef,\n Servo_StartingStyleRule_Release\n);\nimpl_simple_arc_ffi!(\n AppearanceBaseRule,\n Servo_AppearanceBaseRule_AddRef,\n Servo_AppearanceBaseRule_Release\n);\n\nimpl_simple_arc_ffi!(\n LockedPositionTryRule,\n Servo_PositionTryRule_AddRef,\n Servo_PositionTryRule_Release\n);\nimpl_simple_arc_ffi!(\n LockedNestedDeclarationsRule,\n Servo_NestedDeclarationsRule_AddRef,\n Servo_NestedDeclarationsRule_Release\n);\nimpl_simple_arc_ffi!(\n ViewTransitionRule,\n Servo_ViewTransitionRule_AddRef,\n Servo_ViewTransitionRule_Release\n);\n" }, { "path": "style/gecko/conversions.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! This module contains conversion helpers between Servo and Gecko types\n//! Ideally, it would be in geckolib itself, but coherence\n//! forces us to keep the traits and implementations here\n//!\n//! FIXME(emilio): This file should generally just die.\n\n#![allow(unsafe_code)]\n\nuse crate::gecko_bindings::structs::{nsresult, Matrix4x4Components};\nuse crate::stylesheets::RulesMutateError;\nuse crate::values::computed::transform::Matrix3D;\n\nimpl From for nsresult {\n fn from(other: RulesMutateError) -> Self {\n match other {\n RulesMutateError::Syntax => nsresult::NS_ERROR_DOM_SYNTAX_ERR,\n RulesMutateError::IndexSize => nsresult::NS_ERROR_DOM_INDEX_SIZE_ERR,\n RulesMutateError::HierarchyRequest => nsresult::NS_ERROR_DOM_HIERARCHY_REQUEST_ERR,\n RulesMutateError::InvalidState => nsresult::NS_ERROR_DOM_INVALID_STATE_ERR,\n }\n }\n}\n\nimpl<'a> From<&'a Matrix4x4Components> for Matrix3D {\n fn from(m: &'a Matrix4x4Components) -> Matrix3D {\n Matrix3D {\n m11: m[0],\n m12: m[1],\n m13: m[2],\n m14: m[3],\n m21: m[4],\n m22: m[5],\n m23: m[6],\n m24: m[7],\n m31: m[8],\n m32: m[9],\n m33: m[10],\n m34: m[11],\n m41: m[12],\n m42: m[13],\n m43: m[14],\n m44: m[15],\n }\n }\n}\n\nimpl From for Matrix4x4Components {\n fn from(matrix: Matrix3D) -> Self {\n [\n matrix.m11, matrix.m12, matrix.m13, matrix.m14, matrix.m21, matrix.m22, matrix.m23,\n matrix.m24, matrix.m31, matrix.m32, matrix.m33, matrix.m34, matrix.m41, matrix.m42,\n matrix.m43, matrix.m44,\n ]\n }\n}\n" }, { "path": "style/gecko/data.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! Data needed to style a Gecko document.\n\nuse crate::derives::*;\nuse crate::device::Device;\nuse crate::gecko_bindings::bindings;\nuse crate::gecko_bindings::structs::{\n self, ServoStyleSetSizes, StyleSheet as DomStyleSheet, StyleSheetInfo,\n};\nuse crate::invalidation::stylesheets::StylesheetInvalidationSet;\nuse crate::media_queries::MediaList;\nuse crate::properties::ComputedValues;\nuse crate::shared_lock::{SharedRwLockReadGuard, StylesheetGuards};\nuse crate::stylesheets::scope_rule::ImplicitScopeRoot;\nuse crate::stylesheets::{StylesheetContents, StylesheetInDocument};\nuse crate::stylist::Stylist;\nuse atomic_refcell::{AtomicRef, AtomicRefCell, AtomicRefMut};\nuse malloc_size_of::MallocSizeOfOps;\nuse selectors::Element;\nuse servo_arc::Arc;\nuse std::fmt;\n\nuse super::wrapper::GeckoElement;\n\n/// Little wrapper to a Gecko style sheet.\n#[derive(Eq, PartialEq)]\npub struct GeckoStyleSheet(*const DomStyleSheet);\n\n// NOTE(emilio): These are kind of a lie. We allow to make these Send + Sync so that other data\n// structures can also be Send and Sync, but Gecko's stylesheets are main-thread-reference-counted.\n//\n// We assert that we reference-count in the right thread (in the Addref/Release implementations).\n// Sending these to a different thread can't really happen (it could theoretically really happen if\n// we allowed @import rules inside a nested style rule, but that can't happen per spec and would be\n// a parser bug, caught by the asserts).\nunsafe impl Send for GeckoStyleSheet {}\nunsafe impl Sync for GeckoStyleSheet {}\n\nimpl fmt::Debug for GeckoStyleSheet {\n fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\n let contents = self.raw_contents();\n formatter\n .debug_struct(\"GeckoStyleSheet\")\n .field(\"origin\", &contents.origin)\n .field(\"url_data\", &contents.url_data)\n .finish()\n }\n}\n\nimpl GeckoStyleSheet {\n /// Create a `GeckoStyleSheet` from a raw `DomStyleSheet` pointer.\n #[inline]\n pub unsafe fn new(s: *const DomStyleSheet) -> Self {\n debug_assert!(!s.is_null());\n bindings::Gecko_StyleSheet_AddRef(s);\n Self::from_addrefed(s)\n }\n\n /// Create a `GeckoStyleSheet` from a raw `DomStyleSheet` pointer that\n /// already holds a strong reference.\n #[inline]\n pub unsafe fn from_addrefed(s: *const DomStyleSheet) -> Self {\n assert!(!s.is_null());\n GeckoStyleSheet(s)\n }\n\n /// HACK(emilio): This is so that we can avoid crashing release due to\n /// bug 1719963 and can hopefully get a useful report from fuzzers.\n #[inline]\n pub fn hack_is_null(&self) -> bool {\n self.0.is_null()\n }\n\n /// Get the raw `StyleSheet` that we're wrapping.\n pub fn raw(&self) -> &DomStyleSheet {\n unsafe { &*self.0 }\n }\n\n fn inner(&self) -> &StyleSheetInfo {\n unsafe { &*(self.raw().mInner as *const StyleSheetInfo) }\n }\n\n fn raw_contents(&self) -> &StylesheetContents {\n debug_assert!(!self.inner().mContents.mRawPtr.is_null());\n unsafe { &*self.inner().mContents.mRawPtr }\n }\n}\n\nimpl Drop for GeckoStyleSheet {\n fn drop(&mut self) {\n unsafe { bindings::Gecko_StyleSheet_Release(self.0) };\n }\n}\n\nimpl Clone for GeckoStyleSheet {\n fn clone(&self) -> Self {\n unsafe { bindings::Gecko_StyleSheet_AddRef(self.0) };\n GeckoStyleSheet(self.0)\n }\n}\n\nimpl StylesheetInDocument for GeckoStyleSheet {\n fn media<'a>(&'a self, guard: &'a SharedRwLockReadGuard) -> Option<&'a MediaList> {\n use crate::gecko_bindings::structs::mozilla::dom::MediaList as DomMediaList;\n unsafe {\n let dom_media_list = self.raw().mMedia.mRawPtr as *const DomMediaList;\n if dom_media_list.is_null() {\n return None;\n }\n let list = &*(*dom_media_list).mRawList.mRawPtr;\n Some(list.read_with(guard))\n }\n }\n\n // All the stylesheets Servo knows about are enabled, because that state is\n // handled externally by Gecko.\n #[inline]\n fn enabled(&self) -> bool {\n true\n }\n\n #[inline]\n fn contents<'a>(&'a self, _: &'a SharedRwLockReadGuard) -> &'a StylesheetContents {\n self.raw_contents()\n }\n\n fn implicit_scope_root(&self) -> Option {\n unsafe {\n let result = bindings::Gecko_StyleSheet_ImplicitScopeRoot(self.0);\n if result.mRoot.is_null() {\n return if result.mConstructed {\n Some(ImplicitScopeRoot::Constructed)\n } else {\n // Could be genuinely not attached, like user stylesheet.\n None\n };\n }\n\n let root = GeckoElement(result.mRoot.as_ref().unwrap()).opaque();\n Some(if !result.mHost.is_null() {\n let host = GeckoElement(result.mHost.as_ref().unwrap()).opaque();\n if host == root {\n ImplicitScopeRoot::ShadowHost(root)\n } else {\n ImplicitScopeRoot::InShadowTree(root)\n }\n } else {\n ImplicitScopeRoot::InLightTree(root)\n })\n }\n }\n}\n\n/// The container for data that a Servo-backed Gecko document needs to style\n/// itself.\npub struct PerDocumentStyleDataImpl {\n /// Rule processor.\n pub stylist: Stylist,\n\n /// A cache from element to resolved style.\n pub undisplayed_style_cache: crate::traversal::UndisplayedStyleCache,\n\n /// The generation for which our cache is valid.\n pub undisplayed_style_cache_generation: u64,\n}\n\n/// The data itself is an `AtomicRefCell`, which guarantees the proper semantics\n/// and unexpected races while trying to mutate it.\n#[derive(Deref)]\npub struct PerDocumentStyleData(AtomicRefCell);\n\nimpl PerDocumentStyleData {\n /// Create a `PerDocumentStyleData`.\n pub fn new(document: *const structs::Document) -> Self {\n let device = Device::new(document);\n let quirks_mode = device.document().mCompatMode;\n\n PerDocumentStyleData(AtomicRefCell::new(PerDocumentStyleDataImpl {\n stylist: Stylist::new(device, quirks_mode.into()),\n undisplayed_style_cache: Default::default(),\n undisplayed_style_cache_generation: 0,\n }))\n }\n\n /// Get an immutable reference to this style data.\n pub fn borrow(&self) -> AtomicRef<'_, PerDocumentStyleDataImpl> {\n self.0.borrow()\n }\n\n /// Get an mutable reference to this style data.\n pub fn borrow_mut(&self) -> AtomicRefMut<'_, PerDocumentStyleDataImpl> {\n self.0.borrow_mut()\n }\n}\n\nimpl PerDocumentStyleDataImpl {\n /// Recreate the style data if the stylesheets have changed.\n pub fn flush_stylesheets(\n &mut self,\n guard: &SharedRwLockReadGuard,\n ) -> StylesheetInvalidationSet {\n self.stylist.flush(&StylesheetGuards::same(guard))\n }\n\n /// Get the default computed values for this document.\n pub fn default_computed_values(&self) -> &Arc {\n self.stylist.device().default_computed_values_arc()\n }\n\n /// Measure heap usage.\n pub fn add_size_of(&self, ops: &mut MallocSizeOfOps, sizes: &mut ServoStyleSetSizes) {\n self.stylist.add_size_of(ops, sizes);\n }\n}\n\n/// The gecko-specific AuthorStyles instantiation.\npub type AuthorStyles = crate::author_styles::AuthorStyles;\n" }, { "path": "style/gecko/media_features.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! Gecko's media feature list and evaluator.\n\nuse crate::derives::*;\nuse crate::device::Device;\nuse crate::gecko_bindings::bindings;\nuse crate::gecko_bindings::structs;\nuse crate::media_queries::MediaType;\nuse crate::parser::ParserContext;\nuse crate::queries::feature::{AllowsRanges, Evaluator, FeatureFlags, QueryFeatureDescription};\nuse crate::queries::values::{Orientation, PrefersColorScheme};\nuse crate::values::computed::{CSSPixelLength, Context, Ratio, Resolution};\nuse crate::values::specified::color::ForcedColors;\nuse app_units::Au;\nuse euclid::default::Size2D;\n\nfn device_size(device: &Device) -> Size2D {\n let mut width = 0;\n let mut height = 0;\n unsafe {\n bindings::Gecko_MediaFeatures_GetDeviceSize(device.document(), &mut width, &mut height);\n }\n Size2D::new(Au(width), Au(height))\n}\n\n/// https://drafts.csswg.org/mediaqueries-4/#width\nfn eval_width(context: &Context) -> CSSPixelLength {\n CSSPixelLength::new(context.device().au_viewport_size().width.to_f32_px())\n}\n\n/// https://drafts.csswg.org/mediaqueries-4/#device-width\nfn eval_device_width(context: &Context) -> CSSPixelLength {\n CSSPixelLength::new(device_size(context.device()).width.to_f32_px())\n}\n\n/// https://drafts.csswg.org/mediaqueries-4/#height\nfn eval_height(context: &Context) -> CSSPixelLength {\n CSSPixelLength::new(context.device().au_viewport_size().height.to_f32_px())\n}\n\n/// https://drafts.csswg.org/mediaqueries-4/#device-height\nfn eval_device_height(context: &Context) -> CSSPixelLength {\n CSSPixelLength::new(device_size(context.device()).height.to_f32_px())\n}\n\nfn eval_aspect_ratio_for(context: &Context, get_size: F) -> Ratio\nwhere\n F: FnOnce(&Device) -> Size2D,\n{\n let size = get_size(context.device());\n Ratio::new(size.width.0 as f32, size.height.0 as f32)\n}\n\n/// https://drafts.csswg.org/mediaqueries-4/#aspect-ratio\nfn eval_aspect_ratio(context: &Context) -> Ratio {\n eval_aspect_ratio_for(context, Device::au_viewport_size)\n}\n\n/// https://drafts.csswg.org/mediaqueries-4/#device-aspect-ratio\nfn eval_device_aspect_ratio(context: &Context) -> Ratio {\n eval_aspect_ratio_for(context, device_size)\n}\n\n/// https://compat.spec.whatwg.org/#css-media-queries-webkit-device-pixel-ratio\nfn eval_device_pixel_ratio(context: &Context) -> f32 {\n eval_resolution(context).dppx()\n}\n\n/// https://drafts.csswg.org/mediaqueries-4/#orientation\nfn eval_orientation(context: &Context, value: Option) -> bool {\n Orientation::eval(context.device().au_viewport_size(), value)\n}\n\n/// FIXME: There's no spec for `-moz-device-orientation`.\nfn eval_device_orientation(context: &Context, value: Option) -> bool {\n Orientation::eval(device_size(context.device()), value)\n}\n\nfn document_picture_in_picture_enabled(context: &ParserContext) -> bool {\n static_prefs::pref!(\"dom.documentpip.enabled\") || context.chrome_rules_enabled()\n}\n\n/// Values for the display-mode media feature.\n#[derive(Clone, Copy, Debug, FromPrimitive, Parse, PartialEq, ToCss)]\n#[repr(u8)]\n#[allow(missing_docs)]\npub enum DisplayMode {\n Browser = 0,\n MinimalUi,\n Standalone,\n Fullscreen,\n #[parse(condition = \"document_picture_in_picture_enabled\")]\n PictureInPicture,\n}\n\n/// https://w3c.github.io/manifest/#the-display-mode-media-feature\nfn eval_display_mode(context: &Context, query_value: Option) -> bool {\n match query_value {\n Some(v) => {\n v == unsafe {\n bindings::Gecko_MediaFeatures_GetDisplayMode(context.device().document())\n }\n },\n None => true,\n }\n}\n\n/// https://drafts.csswg.org/mediaqueries-4/#grid\nfn eval_grid(_: &Context) -> bool {\n // Gecko doesn't support grid devices (e.g., ttys), so the 'grid' feature\n // is always 0.\n false\n}\n\n/// https://compat.spec.whatwg.org/#css-media-queries-webkit-transform-3d\nfn eval_transform_3d(_: &Context) -> bool {\n true\n}\n\n#[derive(Clone, Copy, Debug, FromPrimitive, Parse, ToCss)]\n#[repr(u8)]\nenum Scan {\n Progressive,\n Interlace,\n}\n\n/// https://drafts.csswg.org/mediaqueries-4/#scan\nfn eval_scan(_: &Context, _: Option) -> bool {\n // Since Gecko doesn't support the 'tv' media type, the 'scan' feature never\n // matches.\n false\n}\n\n/// https://drafts.csswg.org/mediaqueries-4/#color\nfn eval_color(context: &Context) -> i32 {\n unsafe { bindings::Gecko_MediaFeatures_GetColorDepth(context.device().document()) }\n}\n\n/// https://drafts.csswg.org/mediaqueries-4/#color-index\nfn eval_color_index(_: &Context) -> i32 {\n // We should return zero if the device does not use a color lookup table.\n 0\n}\n\n/// https://drafts.csswg.org/mediaqueries-4/#monochrome\nfn eval_monochrome(context: &Context) -> i32 {\n // For color devices we should return 0.\n unsafe { bindings::Gecko_MediaFeatures_GetMonochromeBitsPerPixel(context.device().document()) }\n}\n\n/// Values for the color-gamut media feature.\n/// This implements PartialOrd so that lower values will correctly match\n/// higher capabilities.\n#[derive(Clone, Copy, Debug, FromPrimitive, Parse, PartialEq, PartialOrd, ToCss)]\n#[repr(u8)]\npub enum ColorGamut {\n /// The sRGB gamut.\n Srgb,\n /// The gamut specified by the Display P3 Color Space.\n P3,\n /// The gamut specified by the ITU-R Recommendation BT.2020 Color Space.\n Rec2020,\n}\n\n/// https://drafts.csswg.org/mediaqueries-4/#color-gamut\nfn eval_color_gamut(context: &Context, query_value: Option) -> bool {\n let query_value = match query_value {\n Some(v) => v,\n None => return false,\n };\n let color_gamut =\n unsafe { bindings::Gecko_MediaFeatures_ColorGamut(context.device().document()) };\n // Match if our color gamut is at least as wide as the query value\n query_value <= color_gamut\n}\n\n/// https://drafts.csswg.org/mediaqueries-4/#resolution\nfn eval_resolution(context: &Context) -> Resolution {\n let resolution_dppx =\n unsafe { bindings::Gecko_MediaFeatures_GetResolution(context.device().document()) };\n Resolution::from_dppx(resolution_dppx)\n}\n\n#[derive(Clone, Copy, Debug, FromPrimitive, Parse, ToCss)]\n#[repr(u8)]\nenum PrefersReducedMotion {\n NoPreference,\n Reduce,\n}\n\n#[derive(Clone, Copy, Debug, FromPrimitive, Parse, ToCss)]\n#[repr(u8)]\nenum PrefersReducedTransparency {\n NoPreference,\n Reduce,\n}\n\n/// Values for the dynamic-range and video-dynamic-range media features.\n/// https://drafts.csswg.org/mediaqueries-5/#dynamic-range\n/// This implements PartialOrd so that lower values will correctly match\n/// higher capabilities.\n#[derive(Clone, Copy, Debug, FromPrimitive, Parse, PartialEq, PartialOrd, ToCss)]\n#[repr(u8)]\n#[allow(missing_docs)]\npub enum DynamicRange {\n Standard,\n High,\n}\n\n/// https://drafts.csswg.org/mediaqueries-5/#prefers-reduced-motion\nfn eval_prefers_reduced_motion(\n context: &Context,\n query_value: Option,\n) -> bool {\n let prefers_reduced =\n unsafe { bindings::Gecko_MediaFeatures_PrefersReducedMotion(context.device().document()) };\n let query_value = match query_value {\n Some(v) => v,\n None => return prefers_reduced,\n };\n\n match query_value {\n PrefersReducedMotion::NoPreference => !prefers_reduced,\n PrefersReducedMotion::Reduce => prefers_reduced,\n }\n}\n\n/// https://drafts.csswg.org/mediaqueries-5/#prefers-reduced-transparency\nfn eval_prefers_reduced_transparency(\n context: &Context,\n query_value: Option,\n) -> bool {\n let prefers_reduced = unsafe {\n bindings::Gecko_MediaFeatures_PrefersReducedTransparency(context.device().document())\n };\n let query_value = match query_value {\n Some(v) => v,\n None => return prefers_reduced,\n };\n\n match query_value {\n PrefersReducedTransparency::NoPreference => !prefers_reduced,\n PrefersReducedTransparency::Reduce => prefers_reduced,\n }\n}\n\n/// Possible values for prefers-contrast media query.\n/// https://drafts.csswg.org/mediaqueries-5/#prefers-contrast\n#[derive(Clone, Copy, Debug, FromPrimitive, Parse, PartialEq, ToCss)]\n#[repr(u8)]\npub enum PrefersContrast {\n /// More contrast is preferred.\n More,\n /// Low contrast is preferred.\n Less,\n /// Custom (not more, not less).\n Custom,\n /// The default value if neither high or low contrast is enabled.\n NoPreference,\n}\n\n/// https://drafts.csswg.org/mediaqueries-5/#prefers-contrast\nfn eval_prefers_contrast(context: &Context, query_value: Option) -> bool {\n let prefers_contrast =\n unsafe { bindings::Gecko_MediaFeatures_PrefersContrast(context.device().document()) };\n match query_value {\n Some(v) => v == prefers_contrast,\n None => prefers_contrast != PrefersContrast::NoPreference,\n }\n}\n\n/// https://drafts.csswg.org/mediaqueries-5/#forced-colors\nfn eval_forced_colors(context: &Context, query_value: Option) -> bool {\n let forced = context.device().forced_colors();\n match query_value {\n Some(query_value) => query_value == forced,\n None => forced != ForcedColors::None,\n }\n}\n\n/// Possible values for the inverted-colors media query.\n/// https://drafts.csswg.org/mediaqueries-5/#inverted\n#[derive(Clone, Copy, Debug, FromPrimitive, Parse, ToCss)]\n#[repr(u8)]\nenum InvertedColors {\n /// Colors are displayed normally.\n None,\n /// All pixels within the displayed area have been inverted.\n Inverted,\n}\n\n/// https://drafts.csswg.org/mediaqueries-5/#inverted\nfn eval_inverted_colors(context: &Context, query_value: Option) -> bool {\n let inverted_colors =\n unsafe { bindings::Gecko_MediaFeatures_InvertedColors(context.device().document()) };\n let query_value = match query_value {\n Some(v) => v,\n None => return inverted_colors,\n };\n\n match query_value {\n InvertedColors::None => !inverted_colors,\n InvertedColors::Inverted => inverted_colors,\n }\n}\n\n#[derive(Clone, Copy, Debug, FromPrimitive, Parse, ToCss)]\n#[repr(u8)]\nenum OverflowBlock {\n None,\n Scroll,\n Paged,\n}\n\n/// https://drafts.csswg.org/mediaqueries-4/#mf-overflow-block\nfn eval_overflow_block(context: &Context, query_value: Option) -> bool {\n // For the time being, assume that printing (including previews)\n // is the only time when we paginate, and we are otherwise always\n // scrolling. This is true at the moment in Firefox, but may need\n // updating in the future (e.g., ebook readers built with Stylo, a\n // billboard mode that doesn't support overflow at all).\n //\n // If this ever changes, don't forget to change eval_overflow_inline too.\n let scrolling = context.device().media_type() != MediaType::print();\n let query_value = match query_value {\n Some(v) => v,\n None => return true,\n };\n\n match query_value {\n OverflowBlock::None => false,\n OverflowBlock::Scroll => scrolling,\n OverflowBlock::Paged => !scrolling,\n }\n}\n\n#[derive(Clone, Copy, Debug, FromPrimitive, Parse, ToCss)]\n#[repr(u8)]\nenum OverflowInline {\n None,\n Scroll,\n}\n\n/// https://drafts.csswg.org/mediaqueries-4/#mf-overflow-inline\nfn eval_overflow_inline(context: &Context, query_value: Option) -> bool {\n // See the note in eval_overflow_block.\n let scrolling = context.device().media_type() != MediaType::print();\n let query_value = match query_value {\n Some(v) => v,\n None => return scrolling,\n };\n\n match query_value {\n OverflowInline::None => !scrolling,\n OverflowInline::Scroll => scrolling,\n }\n}\n\n#[derive(Clone, Copy, Debug, FromPrimitive, Parse, ToCss)]\n#[repr(u8)]\nenum Update {\n None,\n Slow,\n Fast,\n}\n\n/// https://drafts.csswg.org/mediaqueries-4/#update\nfn eval_update(context: &Context, query_value: Option) -> bool {\n // This has similar caveats to those described in eval_overflow_block.\n // For now, we report that print (incl. print media simulation,\n // which can in fact update but is limited to the developer tools)\n // is `update: none` and that all other contexts are `update: fast`,\n // which may not be true for future platforms, like e-ink devices.\n let can_update = context.device().media_type() != MediaType::print();\n let query_value = match query_value {\n Some(v) => v,\n None => return can_update,\n };\n\n match query_value {\n Update::None => !can_update,\n Update::Slow => false,\n Update::Fast => can_update,\n }\n}\n\nfn do_eval_prefers_color_scheme(\n context: &Context,\n use_content: bool,\n query_value: Option,\n) -> bool {\n let prefers_color_scheme = unsafe {\n bindings::Gecko_MediaFeatures_PrefersColorScheme(context.device().document(), use_content)\n };\n match query_value {\n Some(v) => prefers_color_scheme == v,\n None => true,\n }\n}\n\n/// https://drafts.csswg.org/mediaqueries-5/#prefers-color-scheme\nfn eval_prefers_color_scheme(context: &Context, query_value: Option) -> bool {\n do_eval_prefers_color_scheme(context, /* use_content = */ false, query_value)\n}\n\nfn eval_content_prefers_color_scheme(\n context: &Context,\n query_value: Option,\n) -> bool {\n do_eval_prefers_color_scheme(context, /* use_content = */ true, query_value)\n}\n\n/// https://drafts.csswg.org/mediaqueries-5/#dynamic-range\nfn eval_dynamic_range(context: &Context, query_value: Option) -> bool {\n let dynamic_range =\n unsafe { bindings::Gecko_MediaFeatures_DynamicRange(context.device().document()) };\n match query_value {\n Some(v) => dynamic_range >= v,\n None => false,\n }\n}\n/// https://drafts.csswg.org/mediaqueries-5/#video-dynamic-range\nfn eval_video_dynamic_range(context: &Context, query_value: Option) -> bool {\n let dynamic_range =\n unsafe { bindings::Gecko_MediaFeatures_VideoDynamicRange(context.device().document()) };\n match query_value {\n Some(v) => dynamic_range >= v,\n None => false,\n }\n}\n\nbitflags! {\n /// https://drafts.csswg.org/mediaqueries-4/#mf-interaction\n struct PointerCapabilities: u8 {\n const COARSE = structs::PointerCapabilities_Coarse;\n const FINE = structs::PointerCapabilities_Fine;\n const HOVER = structs::PointerCapabilities_Hover;\n }\n}\n\nfn primary_pointer_capabilities(context: &Context) -> PointerCapabilities {\n PointerCapabilities::from_bits_truncate(unsafe {\n bindings::Gecko_MediaFeatures_PrimaryPointerCapabilities(context.device().document())\n })\n}\n\nfn all_pointer_capabilities(context: &Context) -> PointerCapabilities {\n PointerCapabilities::from_bits_truncate(unsafe {\n bindings::Gecko_MediaFeatures_AllPointerCapabilities(context.device().document())\n })\n}\n\n#[derive(Clone, Copy, Debug, FromPrimitive, Parse, ToCss)]\n#[repr(u8)]\nenum Pointer {\n None,\n Coarse,\n Fine,\n}\n\nfn eval_pointer_capabilities(\n query_value: Option,\n pointer_capabilities: PointerCapabilities,\n) -> bool {\n let query_value = match query_value {\n Some(v) => v,\n None => return !pointer_capabilities.is_empty(),\n };\n\n match query_value {\n Pointer::None => pointer_capabilities.is_empty(),\n Pointer::Coarse => pointer_capabilities.intersects(PointerCapabilities::COARSE),\n Pointer::Fine => pointer_capabilities.intersects(PointerCapabilities::FINE),\n }\n}\n\n/// https://drafts.csswg.org/mediaqueries-4/#pointer\nfn eval_pointer(context: &Context, query_value: Option) -> bool {\n eval_pointer_capabilities(query_value, primary_pointer_capabilities(context))\n}\n\n/// https://drafts.csswg.org/mediaqueries-4/#descdef-media-any-pointer\nfn eval_any_pointer(context: &Context, query_value: Option) -> bool {\n eval_pointer_capabilities(query_value, all_pointer_capabilities(context))\n}\n\n#[derive(Clone, Copy, Debug, FromPrimitive, Parse, ToCss)]\n#[repr(u8)]\nenum Hover {\n None,\n Hover,\n}\n\nfn eval_hover_capabilities(\n query_value: Option,\n pointer_capabilities: PointerCapabilities,\n) -> bool {\n let can_hover = pointer_capabilities.intersects(PointerCapabilities::HOVER);\n let query_value = match query_value {\n Some(v) => v,\n None => return can_hover,\n };\n\n match query_value {\n Hover::None => !can_hover,\n Hover::Hover => can_hover,\n }\n}\n\n/// https://drafts.csswg.org/mediaqueries-4/#hover\nfn eval_hover(context: &Context, query_value: Option) -> bool {\n eval_hover_capabilities(query_value, primary_pointer_capabilities(context))\n}\n\n/// https://drafts.csswg.org/mediaqueries-4/#descdef-media-any-hover\nfn eval_any_hover(context: &Context, query_value: Option) -> bool {\n eval_hover_capabilities(query_value, all_pointer_capabilities(context))\n}\n\nfn eval_moz_is_glyph(context: &Context) -> bool {\n context.device().document().mIsSVGGlyphsDocument()\n}\n\nfn eval_moz_in_android_pip_mode(context: &Context) -> bool {\n unsafe { bindings::Gecko_MediaFeatures_InAndroidPipMode(context.device().document()) }\n}\n\nfn eval_moz_print_preview(context: &Context) -> bool {\n let is_print_preview = context.device().is_print_preview();\n if is_print_preview {\n debug_assert_eq!(context.device().media_type(), MediaType::print());\n }\n is_print_preview\n}\n\nfn eval_moz_is_resource_document(context: &Context) -> bool {\n unsafe { bindings::Gecko_MediaFeatures_IsResourceDocument(context.device().document()) }\n}\n\n/// Allows front-end CSS to discern platform via media queries.\n#[derive(Clone, Copy, Debug, FromPrimitive, Parse, ToCss)]\n#[repr(u8)]\npub enum Platform {\n /// Matches any Android version.\n Android,\n /// For our purposes here, \"linux\" is just \"gtk\" (so unix-but-not-mac).\n /// There's no need for our front-end code to differentiate between those\n /// platforms and they already use the \"linux\" string elsewhere (e.g.,\n /// toolkit/themes/linux).\n Linux,\n /// Matches any iOS version.\n Ios,\n /// Matches any macOS version.\n Macos,\n /// Matches any Windows version.\n Windows,\n}\n\nfn eval_moz_platform(_: &Context, query_value: Option) -> bool {\n let query_value = match query_value {\n Some(v) => v,\n None => return false,\n };\n\n unsafe { bindings::Gecko_MediaFeatures_MatchesPlatform(query_value) }\n}\n\n/// Allows front-end CSS to discern gtk theme via media queries.\n#[derive(Clone, Copy, Debug, FromPrimitive, Parse, PartialEq, ToCss)]\n#[repr(u8)]\npub enum GtkThemeFamily {\n /// Unknown theme family.\n Unknown = 0,\n /// Adwaita, the default GTK theme.\n Adwaita,\n /// Breeze, the default KDE theme.\n Breeze,\n /// Yaru, the default Ubuntu theme.\n Yaru,\n}\n\nfn eval_gtk_theme_family(_: &Context, query_value: Option) -> bool {\n let family = unsafe { bindings::Gecko_MediaFeatures_GtkThemeFamily() };\n match query_value {\n Some(v) => v == family,\n None => return family != GtkThemeFamily::Unknown,\n }\n}\n\n/// Values for the scripting media feature.\n/// https://drafts.csswg.org/mediaqueries-5/#scripting\n#[derive(Clone, Copy, Debug, FromPrimitive, Parse, PartialEq, ToCss)]\n#[repr(u8)]\npub enum Scripting {\n /// Scripting is not supported or not enabled\n None,\n /// Scripting is supported and enabled, but only for initial page load\n /// We will never match this value as it is intended for non-browser user agents,\n /// but it is part of the spec so we should still parse it.\n /// See: https://github.com/w3c/csswg-drafts/issues/8621\n InitialOnly,\n /// Scripting is supported and enabled\n Enabled,\n}\n\n/// https://drafts.csswg.org/mediaqueries-5/#scripting\nfn eval_scripting(context: &Context, query_value: Option) -> bool {\n let scripting = unsafe { bindings::Gecko_MediaFeatures_Scripting(context.device().document()) };\n match query_value {\n Some(v) => v == scripting,\n None => scripting != Scripting::None,\n }\n}\n\nfn eval_moz_overlay_scrollbars(context: &Context) -> bool {\n unsafe { bindings::Gecko_MediaFeatures_UseOverlayScrollbars(context.device().document()) }\n}\n\nfn eval_moz_mac_rtl(context: &Context) -> bool {\n unsafe { bindings::Gecko_MediaFeatures_MacRTL(context.device().document()) }\n}\n\nfn eval_moz_native_theme(context: &Context) -> bool {\n if context.device().document().mForceNonNativeTheme() {\n return false;\n }\n static_prefs::pref!(\"browser.theme.native-theme\")\n}\n\nfn get_lnf_int(int_id: i32) -> i32 {\n unsafe { bindings::Gecko_GetLookAndFeelInt(int_id) }\n}\n\nfn get_lnf_int_as_bool(int_id: i32) -> bool {\n get_lnf_int(int_id) != 0\n}\n\nmacro_rules! lnf_int_feature {\n ($feature_name:expr, $int_id:ident, $get_value:ident) => {{\n fn __eval(_: &Context) -> bool {\n $get_value(bindings::LookAndFeel_IntID::$int_id as i32)\n }\n\n feature!(\n $feature_name,\n AllowsRanges::No,\n Evaluator::BoolInteger(__eval),\n FeatureFlags::CHROME_AND_UA_ONLY,\n )\n }};\n ($feature_name:expr, $int_id:ident) => {{\n lnf_int_feature!($feature_name, $int_id, get_lnf_int_as_bool)\n }};\n}\n\n/// Adding new media features requires (1) adding the new feature to this\n/// array, with appropriate entries (and potentially any new code needed\n/// to support new types in these entries and (2) ensuring that either\n/// nsPresContext::MediaFeatureValuesChanged is called when the value that\n/// would be returned by the evaluator function could change.\npub static MEDIA_FEATURES: [QueryFeatureDescription; 60] = [\n feature!(\n atom!(\"width\"),\n AllowsRanges::Yes,\n Evaluator::Length(eval_width),\n FeatureFlags::VIEWPORT_DEPENDENT,\n ),\n feature!(\n atom!(\"height\"),\n AllowsRanges::Yes,\n Evaluator::Length(eval_height),\n FeatureFlags::VIEWPORT_DEPENDENT,\n ),\n feature!(\n atom!(\"aspect-ratio\"),\n AllowsRanges::Yes,\n Evaluator::NumberRatio(eval_aspect_ratio),\n FeatureFlags::VIEWPORT_DEPENDENT,\n ),\n feature!(\n atom!(\"orientation\"),\n AllowsRanges::No,\n keyword_evaluator!(eval_orientation, Orientation),\n FeatureFlags::VIEWPORT_DEPENDENT,\n ),\n feature!(\n atom!(\"device-width\"),\n AllowsRanges::Yes,\n Evaluator::Length(eval_device_width),\n FeatureFlags::empty(),\n ),\n feature!(\n atom!(\"device-height\"),\n AllowsRanges::Yes,\n Evaluator::Length(eval_device_height),\n FeatureFlags::empty(),\n ),\n feature!(\n atom!(\"device-aspect-ratio\"),\n AllowsRanges::Yes,\n Evaluator::NumberRatio(eval_device_aspect_ratio),\n FeatureFlags::empty(),\n ),\n feature!(\n atom!(\"-moz-device-orientation\"),\n AllowsRanges::No,\n keyword_evaluator!(eval_device_orientation, Orientation),\n FeatureFlags::empty(),\n ),\n // Webkit extensions that we support for de-facto web compatibility.\n // -webkit-{min|max}-device-pixel-ratio (controlled with its own pref):\n feature!(\n atom!(\"device-pixel-ratio\"),\n AllowsRanges::Yes,\n Evaluator::Float(eval_device_pixel_ratio),\n FeatureFlags::WEBKIT_PREFIX,\n ),\n // -webkit-transform-3d.\n feature!(\n atom!(\"transform-3d\"),\n AllowsRanges::No,\n Evaluator::BoolInteger(eval_transform_3d),\n FeatureFlags::WEBKIT_PREFIX,\n ),\n feature!(\n atom!(\"-moz-device-pixel-ratio\"),\n AllowsRanges::Yes,\n Evaluator::Float(eval_device_pixel_ratio),\n FeatureFlags::empty(),\n ),\n feature!(\n atom!(\"resolution\"),\n AllowsRanges::Yes,\n Evaluator::Resolution(eval_resolution),\n FeatureFlags::empty(),\n ),\n feature!(\n atom!(\"display-mode\"),\n AllowsRanges::No,\n keyword_evaluator!(eval_display_mode, DisplayMode),\n FeatureFlags::empty(),\n ),\n feature!(\n atom!(\"grid\"),\n AllowsRanges::No,\n Evaluator::BoolInteger(eval_grid),\n FeatureFlags::empty(),\n ),\n feature!(\n atom!(\"scan\"),\n AllowsRanges::No,\n keyword_evaluator!(eval_scan, Scan),\n FeatureFlags::empty(),\n ),\n feature!(\n atom!(\"color\"),\n AllowsRanges::Yes,\n Evaluator::Integer(eval_color),\n FeatureFlags::empty(),\n ),\n feature!(\n atom!(\"color-index\"),\n AllowsRanges::Yes,\n Evaluator::Integer(eval_color_index),\n FeatureFlags::empty(),\n ),\n feature!(\n atom!(\"monochrome\"),\n AllowsRanges::Yes,\n Evaluator::Integer(eval_monochrome),\n FeatureFlags::empty(),\n ),\n feature!(\n atom!(\"color-gamut\"),\n AllowsRanges::No,\n keyword_evaluator!(eval_color_gamut, ColorGamut),\n FeatureFlags::empty(),\n ),\n feature!(\n atom!(\"prefers-reduced-motion\"),\n AllowsRanges::No,\n keyword_evaluator!(eval_prefers_reduced_motion, PrefersReducedMotion),\n FeatureFlags::empty(),\n ),\n feature!(\n atom!(\"prefers-reduced-transparency\"),\n AllowsRanges::No,\n keyword_evaluator!(\n eval_prefers_reduced_transparency,\n PrefersReducedTransparency\n ),\n FeatureFlags::empty(),\n ),\n feature!(\n atom!(\"prefers-contrast\"),\n AllowsRanges::No,\n keyword_evaluator!(eval_prefers_contrast, PrefersContrast),\n FeatureFlags::empty(),\n ),\n feature!(\n atom!(\"forced-colors\"),\n AllowsRanges::No,\n keyword_evaluator!(eval_forced_colors, ForcedColors),\n FeatureFlags::empty(),\n ),\n feature!(\n atom!(\"inverted-colors\"),\n AllowsRanges::No,\n keyword_evaluator!(eval_inverted_colors, InvertedColors),\n FeatureFlags::empty(),\n ),\n feature!(\n atom!(\"overflow-block\"),\n AllowsRanges::No,\n keyword_evaluator!(eval_overflow_block, OverflowBlock),\n FeatureFlags::empty(),\n ),\n feature!(\n atom!(\"overflow-inline\"),\n AllowsRanges::No,\n keyword_evaluator!(eval_overflow_inline, OverflowInline),\n FeatureFlags::empty(),\n ),\n feature!(\n atom!(\"update\"),\n AllowsRanges::No,\n keyword_evaluator!(eval_update, Update),\n FeatureFlags::empty(),\n ),\n feature!(\n atom!(\"prefers-color-scheme\"),\n AllowsRanges::No,\n keyword_evaluator!(eval_prefers_color_scheme, PrefersColorScheme),\n FeatureFlags::empty(),\n ),\n feature!(\n atom!(\"dynamic-range\"),\n AllowsRanges::No,\n keyword_evaluator!(eval_dynamic_range, DynamicRange),\n FeatureFlags::empty(),\n ),\n feature!(\n atom!(\"video-dynamic-range\"),\n AllowsRanges::No,\n keyword_evaluator!(eval_video_dynamic_range, DynamicRange),\n FeatureFlags::empty(),\n ),\n feature!(\n atom!(\"scripting\"),\n AllowsRanges::No,\n keyword_evaluator!(eval_scripting, Scripting),\n FeatureFlags::empty(),\n ),\n // Evaluates to the preferred color scheme for content. Only useful in\n // chrome context, where the chrome color-scheme and the content\n // color-scheme might differ.\n feature!(\n atom!(\"-moz-content-prefers-color-scheme\"),\n AllowsRanges::No,\n keyword_evaluator!(eval_content_prefers_color_scheme, PrefersColorScheme),\n FeatureFlags::CHROME_AND_UA_ONLY,\n ),\n feature!(\n atom!(\"pointer\"),\n AllowsRanges::No,\n keyword_evaluator!(eval_pointer, Pointer),\n FeatureFlags::empty(),\n ),\n feature!(\n atom!(\"any-pointer\"),\n AllowsRanges::No,\n keyword_evaluator!(eval_any_pointer, Pointer),\n FeatureFlags::empty(),\n ),\n feature!(\n atom!(\"hover\"),\n AllowsRanges::No,\n keyword_evaluator!(eval_hover, Hover),\n FeatureFlags::empty(),\n ),\n feature!(\n atom!(\"any-hover\"),\n AllowsRanges::No,\n keyword_evaluator!(eval_any_hover, Hover),\n FeatureFlags::empty(),\n ),\n // Internal -moz-is-glyph media feature: applies only inside SVG glyphs.\n // Internal because it is really only useful in the user agent anyway\n // and therefore not worth standardizing.\n feature!(\n atom!(\"-moz-is-glyph\"),\n AllowsRanges::No,\n Evaluator::BoolInteger(eval_moz_is_glyph),\n FeatureFlags::CHROME_AND_UA_ONLY,\n ),\n feature!(\n atom!(\"-moz-in-android-pip-mode\"),\n AllowsRanges::No,\n Evaluator::BoolInteger(eval_moz_in_android_pip_mode),\n FeatureFlags::CHROME_AND_UA_ONLY,\n ),\n feature!(\n atom!(\"-moz-is-resource-document\"),\n AllowsRanges::No,\n Evaluator::BoolInteger(eval_moz_is_resource_document),\n FeatureFlags::CHROME_AND_UA_ONLY,\n ),\n feature!(\n atom!(\"-moz-platform\"),\n AllowsRanges::No,\n keyword_evaluator!(eval_moz_platform, Platform),\n FeatureFlags::CHROME_AND_UA_ONLY,\n ),\n feature!(\n atom!(\"-moz-gtk-theme-family\"),\n AllowsRanges::No,\n keyword_evaluator!(eval_gtk_theme_family, GtkThemeFamily),\n FeatureFlags::CHROME_AND_UA_ONLY,\n ),\n feature!(\n atom!(\"-moz-print-preview\"),\n AllowsRanges::No,\n Evaluator::BoolInteger(eval_moz_print_preview),\n FeatureFlags::CHROME_AND_UA_ONLY,\n ),\n feature!(\n atom!(\"-moz-overlay-scrollbars\"),\n AllowsRanges::No,\n Evaluator::BoolInteger(eval_moz_overlay_scrollbars),\n FeatureFlags::CHROME_AND_UA_ONLY,\n ),\n lnf_int_feature!(atom!(\"-moz-menubar-drag\"), MenuBarDrag),\n lnf_int_feature!(atom!(\"-moz-mac-big-sur-theme\"), MacBigSurTheme),\n lnf_int_feature!(atom!(\"-moz-mac-tahoe-theme\"), MacTahoeTheme),\n feature!(\n atom!(\"-moz-mac-rtl\"),\n AllowsRanges::No,\n Evaluator::BoolInteger(eval_moz_mac_rtl),\n FeatureFlags::CHROME_AND_UA_ONLY,\n ),\n feature!(\n atom!(\"-moz-native-theme\"),\n AllowsRanges::No,\n Evaluator::BoolInteger(eval_moz_native_theme),\n FeatureFlags::CHROME_AND_UA_ONLY,\n ),\n lnf_int_feature!(\n atom!(\"-moz-windows-accent-color-in-titlebar\"),\n WindowsAccentColorInTitlebar\n ),\n lnf_int_feature!(atom!(\"-moz-windows-mica\"), WindowsMica),\n lnf_int_feature!(atom!(\"-moz-windows-mica-popups\"), WindowsMicaPopups),\n lnf_int_feature!(atom!(\"-moz-swipe-animation-enabled\"), SwipeAnimationEnabled),\n lnf_int_feature!(atom!(\"-moz-gtk-csd-available\"), GTKCSDAvailable),\n lnf_int_feature!(\n atom!(\"-moz-gtk-csd-transparency-available\"),\n GTKCSDTransparencyAvailable\n ),\n lnf_int_feature!(atom!(\"-moz-gtk-csd-minimize-button\"), GTKCSDMinimizeButton),\n lnf_int_feature!(atom!(\"-moz-gtk-csd-maximize-button\"), GTKCSDMaximizeButton),\n lnf_int_feature!(atom!(\"-moz-gtk-csd-close-button\"), GTKCSDCloseButton),\n lnf_int_feature!(\n atom!(\"-moz-gtk-csd-reversed-placement\"),\n GTKCSDReversedPlacement\n ),\n lnf_int_feature!(atom!(\"-moz-system-dark-theme\"), SystemUsesDarkTheme),\n lnf_int_feature!(atom!(\"-moz-panel-animations\"), PanelAnimations),\n];\n" }, { "path": "style/gecko/mod.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! Gecko-specific style-system bits.\n\n#[macro_use]\nmod non_ts_pseudo_class_list;\n\npub mod arc_types;\npub mod conversions;\npub mod data;\npub mod media_features;\npub mod pseudo_element;\npub mod restyle_damage;\npub mod selector_parser;\npub mod snapshot;\npub mod snapshot_helpers;\npub mod traversal;\npub mod url;\npub mod wrapper;\n" }, { "path": "style/gecko/non_ts_pseudo_class_list.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n/*\n * This file contains a helper macro includes all supported non-tree-structural\n * pseudo-classes.\n *\n * FIXME: Find a way to autogenerate this file.\n *\n * Expected usage is as follows:\n * ```\n * macro_rules! pseudo_class_macro{\n * ([$(($css:expr, $name:ident, $state:tt, $flags:tt),)*]) => {\n * // do stuff\n * }\n * }\n * apply_non_ts_list!(pseudo_class_macro)\n * ```\n *\n * $state can be either \"_\" or an expression of type ElementState. If present,\n * the semantics are that the pseudo-class matches if any of the bits in\n * $state are set on the element.\n * $flags can be either \"_\" or an expression of type NonTSPseudoClassFlag,\n * see selector_parser.rs for more details.\n */\n\nmacro_rules! apply_non_ts_list {\n ($apply_macro:ident) => {\n $apply_macro! {\n [\n (\"-moz-table-border-nonzero\", MozTableBorderNonzero, _, PSEUDO_CLASS_ENABLED_IN_UA_SHEETS),\n (\"-moz-select-list-box\", MozSelectListBox, _, PSEUDO_CLASS_ENABLED_IN_UA_SHEETS_AND_CHROME),\n (\"link\", Link, UNVISITED, _),\n (\"any-link\", AnyLink, VISITED_OR_UNVISITED, _),\n (\"visited\", Visited, VISITED, _),\n (\"active\", Active, ACTIVE, _),\n (\"autofill\", Autofill, AUTOFILL, _),\n (\"checked\", Checked, CHECKED, _),\n (\"defined\", Defined, DEFINED, _),\n (\"disabled\", Disabled, DISABLED, _),\n (\"enabled\", Enabled, ENABLED, _),\n (\"focus\", Focus, FOCUS, _),\n (\"focus-within\", FocusWithin, FOCUS_WITHIN, _),\n (\"focus-visible\", FocusVisible, FOCUSRING, _),\n (\"has-slotted\", HasSlotted, HAS_SLOTTED, _),\n (\"hover\", Hover, HOVER, _),\n (\"active-view-transition\", ActiveViewTransition, ACTIVE_VIEW_TRANSITION, _),\n (\"-moz-drag-over\", MozDragOver, DRAGOVER, _),\n (\"target\", Target, URLTARGET, _),\n (\"indeterminate\", Indeterminate, INDETERMINATE, _),\n (\"-moz-inert\", MozInert, INERT, PSEUDO_CLASS_ENABLED_IN_UA_SHEETS),\n (\"-moz-devtools-highlighted\", MozDevtoolsHighlighted, DEVTOOLS_HIGHLIGHTED, PSEUDO_CLASS_ENABLED_IN_UA_SHEETS),\n (\"-moz-styleeditor-transitioning\", MozStyleeditorTransitioning, STYLEEDITOR_TRANSITIONING, PSEUDO_CLASS_ENABLED_IN_UA_SHEETS),\n (\"fullscreen\", Fullscreen, FULLSCREEN, _),\n (\"modal\", Modal, MODAL, _),\n (\"open\", Open, OPEN, _),\n (\"-moz-topmost-modal\", MozTopmostModal, TOPMOST_MODAL, PSEUDO_CLASS_ENABLED_IN_UA_SHEETS),\n (\"-moz-broken\", MozBroken, BROKEN, PSEUDO_CLASS_ENABLED_IN_UA_SHEETS_AND_CHROME),\n (\"-moz-has-dir-attr\", MozHasDirAttr, HAS_DIR_ATTR, PSEUDO_CLASS_ENABLED_IN_UA_SHEETS),\n (\"-moz-dir-attr-ltr\", MozDirAttrLTR, HAS_DIR_ATTR_LTR, PSEUDO_CLASS_ENABLED_IN_UA_SHEETS),\n (\"-moz-dir-attr-rtl\", MozDirAttrRTL, HAS_DIR_ATTR_RTL, PSEUDO_CLASS_ENABLED_IN_UA_SHEETS),\n (\"-moz-dir-attr-like-auto\", MozDirAttrLikeAuto, HAS_DIR_ATTR_LIKE_AUTO, PSEUDO_CLASS_ENABLED_IN_UA_SHEETS),\n\n (\"-moz-autofill-preview\", MozAutofillPreview, AUTOFILL_PREVIEW, PSEUDO_CLASS_ENABLED_IN_UA_SHEETS_AND_CHROME),\n (\"-moz-value-empty\", MozValueEmpty, VALUE_EMPTY, PSEUDO_CLASS_ENABLED_IN_UA_SHEETS),\n (\"-moz-revealed\", MozRevealed, REVEALED, PSEUDO_CLASS_ENABLED_IN_UA_SHEETS),\n (\"-moz-suppress-for-print-selection\", MozSuppressForPrintSelection, SUPPRESS_FOR_PRINT_SELECTION, PSEUDO_CLASS_ENABLED_IN_UA_SHEETS),\n\n (\"-moz-math-increment-script-level\", MozMathIncrementScriptLevel, INCREMENT_SCRIPT_LEVEL, _),\n\n (\"required\", Required, REQUIRED, _),\n (\"popover-open\", PopoverOpen, POPOVER_OPEN, _),\n (\"optional\", Optional, OPTIONAL_, _),\n (\"valid\", Valid, VALID, _),\n (\"invalid\", Invalid, INVALID, _),\n (\"in-range\", InRange, INRANGE, _),\n (\"out-of-range\", OutOfRange, OUTOFRANGE, _),\n (\"default\", Default, DEFAULT, _),\n (\"placeholder-shown\", PlaceholderShown, PLACEHOLDER_SHOWN, _),\n (\"read-only\", ReadOnly, READONLY, _),\n (\"read-write\", ReadWrite, READWRITE, _),\n (\"user-valid\", UserValid, USER_VALID, _),\n (\"user-invalid\", UserInvalid, USER_INVALID, _),\n (\"-moz-meter-optimum\", MozMeterOptimum, OPTIMUM, _),\n (\"-moz-meter-sub-optimum\", MozMeterSubOptimum, SUB_OPTIMUM, _),\n (\"-moz-meter-sub-sub-optimum\", MozMeterSubSubOptimum, SUB_SUB_OPTIMUM, _),\n\n (\"-moz-first-node\", MozFirstNode, _, _),\n (\"-moz-last-node\", MozLastNode, _, _),\n (\"-moz-only-whitespace\", MozOnlyWhitespace, _, _),\n (\"-moz-native-anonymous\", MozNativeAnonymous, _, PSEUDO_CLASS_ENABLED_IN_UA_SHEETS),\n (\"-moz-placeholder\", MozPlaceholder, _, _),\n\n // Media element pseudo classes\n (\"paused\", Paused, PAUSED, _),\n (\"playing\", Playing, PAUSED, _),\n (\"seeking\", Seeking, SEEKING, _),\n (\"buffering\", Buffering, BUFFERING, _),\n (\"stalled\", Stalled, STALLED, _),\n (\"muted\", Muted, MUTED, _),\n (\"volume-locked\", VolumeLocked, _, _),\n\n\n // NOTE(emilio): Pseudo-classes below only depend on document state, and thus\n // conceptually they should probably be media queries instead.\n //\n // However that has a set of trade-offs that might not be worth making. In\n // particular, such media queries would prevent documents that match them from\n // sharing user-agent stylesheets with documents that don't. Also, changes between\n // media query results are more expensive than document state changes. So for now\n // making them pseudo-classes is probably the right trade-off.\n (\"-moz-is-html\", MozIsHTML, _, PSEUDO_CLASS_ENABLED_IN_UA_SHEETS),\n (\"-moz-window-inactive\", MozWindowInactive, _, _),\n ]\n }\n }\n}\n" }, { "path": "style/gecko/pseudo_element.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\n//! Gecko's definition of a pseudo-element.\n//!\n//! Note that a few autogenerated bits of this live in\n//! `pseudo_element_definition.mako.rs`. If you touch that file, you probably\n//! need to update the checked-in files for Servo.\n\nuse crate::gecko_bindings::structs::PseudoStyleType;\nuse crate::properties::longhands::display::computed_value::T as Display;\nuse crate::properties::{ComputedValues, PropertyFlags};\nuse crate::selector_parser::{PseudoElementCascadeType, SelectorImpl};\nuse crate::str::{starts_with_ignore_ascii_case, string_as_ascii_lowercase};\nuse crate::string_cache::Atom;\nuse crate::values::serialize_atom_identifier;\nuse crate::values::AtomIdent;\nuse cssparser::{Parser, ToCss};\nuse selectors::parser::PseudoElement as PseudoElementTrait;\nuse static_prefs::pref;\nuse std::fmt;\nuse style_traits::ParseError;\n\nbitflags! {\n /// Various pseudo-element flags, see pseudo_elements.toml and anonymous_boxes.toml for the\n /// meaning.\n #[derive(Clone, Copy, Default)]\n pub struct PseudoStyleTypeFlags : u16 {\n /// No flags\n const NONE = 0;\n /// Whether we're enabled in UA sheets.\n const ENABLED_IN_UA = 1 << 0;\n /// Whether we're enabled in chrome sheets.\n const ENABLED_IN_CHROME = 1 << 1;\n /// Whether we're enabled by a pref.\n const ENABLED_BY_PREF = 1 << 2;\n /// Whether we're an anonymous box.\n const IS_PSEUDO_ELEMENT = 1 << 3;\n /// Whether we're a CSS2 pseudo-element.\n const IS_CSS2 = 1 << 4;\n /// Whether we're an eagerly-cascaded pseudo-element.\n const IS_EAGER = 1 << 5;\n /// Whether we can be created by JS\n const IS_JS_CREATED_NAC = 1 << 6;\n /// Whether we can be a flex or grid item.\n const IS_FLEX_OR_GRID_ITEM = 1 << 7;\n /// Whether we're backed by a real element.\n const IS_ELEMENT_BACKED = 1 << 8;\n /// Whether we're a tree-abiding pseudo as per\n /// https://drafts.csswg.org/css-pseudo-4/#treelike\n const IS_TREE_ABIDING = 1 << 9;\n /// Whether we support user-action state pseudo-classes after the pseudo-element.\n const SUPPORTS_USER_ACTION_STATE = 1 << 10;\n /// Whether we are an inheriting anon-box.\n const IS_INHERITING_ANON_BOX = 1 << 11;\n /// Whether we are a non-inheriting anon box.\n const IS_NON_INHERITING_ANON_BOX = 1 << 12;\n /// Combo of the above to cover all anon boxes.\n const IS_ANON_BOX = Self::IS_INHERITING_ANON_BOX.bits() |\n Self::IS_NON_INHERITING_ANON_BOX.bits();\n /// Whether we're a wrapping anon box.\n const IS_WRAPPER_ANON_BOX = 1 << 13;\n /// Whether we parse as an element-backed pseudo-element.\n const PARSES_AS_ELEMENT_BACKED = 1 << 14;\n }\n}\n\ninclude!(concat!(\n env!(\"OUT_DIR\"),\n \"/gecko/pseudo_element_definition.rs\"\n));\n\n/// The target we are using for parsing pseudo-elements.\npub enum Target {\n /// When parsing a selector, we want to use the full syntax.\n Selector,\n /// When parsing the pseudo-element string (from CSSOM), we only accept CusomIdent for named\n /// view transition pseudo-elements.\n Cssom,\n}\n\n/// The type to hold the value of ``.\n///\n/// ` = ? | `\n/// ` = '*' | `\n/// ` = ['.' ]+`\n///\n/// This type should have at least one element.\n/// If there is no , the first element would be the universal symbol, i.e. '*'.\n/// In other words, when we match it, \".abc\" is the same as \"*.abc\".\n/// Note that we also serialize \".abc\" as \"*.abc\".\n///\n/// We use a single ThinVec<> to represent this structure to avoid allocating too much memory for a\n/// single selectors::parser::Component (max: 24 bytes) and PseudoElement (max: 16 bytes).\n///\n/// https://drafts.csswg.org/css-view-transitions-2/#typedef-pt-name-and-class-selector\n#[derive(Clone, Debug, Eq, Hash, MallocSizeOf, PartialEq, ToShmem)]\npub struct PtNameAndClassSelector(thin_vec::ThinVec);\n\nimpl PtNameAndClassSelector {\n /// Constructs a new one from a name.\n pub fn from_name(name: Atom) -> Self {\n Self(thin_vec::thin_vec![name])\n }\n\n /// Returns the name component.\n pub fn name(&self) -> &Atom {\n debug_assert!(!self.0.is_empty());\n self.0.first().expect(\"Shouldn't be empty\")\n }\n\n /// Returns the classes component.\n pub fn classes(&self) -> &[Atom] {\n debug_assert!(!self.0.is_empty());\n &self.0[1..]\n }\n\n /// Returns the vector we store.\n pub fn name_and_classes(&self) -> &thin_vec::ThinVec {\n &self.0\n }\n\n /// Parse the pseudo-element tree name and/or class.\n /// |for_selector| is true if we are parsing the CSS selectors and so need to check the\n /// universal symbol, i.e. '*', and classes.\n // Note: We share the same type for both pseudo-element and pseudo-element selector. The\n // universal symbol (i.e. '*') and `` are used only in the selector (for\n // matching).\n pub fn parse<'i, 't>(\n input: &mut Parser<'i, 't>,\n target: Target,\n ) -> Result> {\n use crate::values::CustomIdent;\n use cssparser::Token;\n use style_traits::StyleParseErrorKind;\n\n // = '*' | \n let parse_pt_name = |input: &mut Parser<'i, '_>| {\n // For pseudo-element string, we don't accept '*'.\n if matches!(target, Target::Selector)\n && input.try_parse(|i| i.expect_delim('*')).is_ok()\n {\n Ok(atom!(\"*\"))\n } else {\n CustomIdent::parse(input, &[]).map(|c| c.0)\n }\n };\n let name = input.try_parse(parse_pt_name);\n\n // Skip for pseudo-element string.\n if matches!(target, Target::Cssom) {\n return name.map(Self::from_name);\n }\n\n // = ['.' ]+\n let parse_pt_class = |input: &mut Parser<'i, '_>| {\n // The white space is forbidden:\n // 1. Between and \n // 2. Between any of the components of .\n let location = input.current_source_location();\n match input.next_including_whitespace()? {\n Token::Delim('.') => (),\n t => return Err(location.new_unexpected_token_error(t.clone())),\n }\n // Whitespace is not allowed between '.' and the class name.\n if let Ok(token) = input.try_parse(|i| i.expect_whitespace()) {\n return Err(input.new_unexpected_token_error(Token::WhiteSpace(token)));\n }\n CustomIdent::parse(input, &[]).map(|c| c.0)\n };\n // If there is no ``, it's fine to have whitespaces before the first '.'.\n if name.is_err() {\n input.skip_whitespace();\n }\n let mut classes = thin_vec::ThinVec::new();\n while let Ok(class) = input.try_parse(parse_pt_class) {\n classes.push(class);\n }\n\n // If we don't have ``, we must have ``, per the\n // syntax: ` ? | `.\n if name.is_err() && classes.is_empty() {\n return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError));\n }\n\n // Use the universal symbol as the first element to present the part of\n // `` because they are equivalent (and the serialization is the same).\n let mut result = thin_vec::thin_vec![name.unwrap_or(atom!(\"*\"))];\n result.append(&mut classes);\n\n Ok(Self(result))\n }\n}\n\nimpl ToCss for PtNameAndClassSelector {\n fn to_css(&self, dest: &mut W) -> fmt::Result\n where\n W: fmt::Write,\n {\n let name = self.name();\n if name == &atom!(\"*\") {\n // serialize_atom_identifier() may serialize \"*\" as \"\\*\", so we handle it separately.\n dest.write_char('*')?;\n } else {\n serialize_atom_identifier(name, dest)?;\n }\n\n for class in self.classes() {\n dest.write_char('.')?;\n serialize_atom_identifier(class, dest)?;\n }\n\n Ok(())\n }\n}\n\nimpl PseudoElementTrait for PseudoElement {\n type Impl = SelectorImpl;\n\n // ::slotted() should support all tree-abiding pseudo-elements, see\n // https://drafts.csswg.org/css-scoping/#slotted-pseudo\n // https://drafts.csswg.org/css-pseudo-4/#treelike\n #[inline]\n fn valid_after_slotted(&self) -> bool {\n self.flags()\n .intersects(PseudoStyleTypeFlags::IS_TREE_ABIDING)\n }\n\n // ::before/::after should support ::marker, but no others.\n // https://drafts.csswg.org/css-pseudo-4/#marker-pseudo\n #[inline]\n fn valid_after_before_or_after(&self) -> bool {\n matches!(*self, Self::Marker)\n }\n\n #[inline]\n fn accepts_state_pseudo_classes(&self) -> bool {\n // Note: if the pseudo element is a descendants of a pseudo element, `only-child` should be\n // allowed after it.\n self.supports_user_action_state() || self.is_in_pseudo_element_tree()\n }\n\n #[inline]\n fn specificity_count(&self) -> u32 {\n self.specificity_count()\n }\n\n #[inline]\n fn is_in_pseudo_element_tree(&self) -> bool {\n // All the named view transition pseudo-elements are the descendants of a pseudo-element\n // root.\n self.is_named_view_transition()\n }\n\n fn parses_as_element_backed(&self) -> bool {\n self.flags()\n .intersects(PseudoStyleTypeFlags::PARSES_AS_ELEMENT_BACKED)\n }\n\n /// Whether the current pseudo element is ::before or ::after.\n #[inline]\n fn is_before_or_after(&self) -> bool {\n matches!(*self, PseudoElement::Before | PseudoElement::After)\n }\n}\n\nimpl PseudoElement {\n /// Whether this pseudo-element is \"element-backed\", which means that it inherits from its regular\n /// flat tree parent, which might not be the originating element.\n #[inline]\n pub fn is_element_backed(&self) -> bool {\n self.flags()\n .intersects(PseudoStyleTypeFlags::IS_ELEMENT_BACKED)\n }\n\n /// Returns the kind of cascade type that a given pseudo is going to use.\n ///\n /// In Gecko we only compute ::before and ::after eagerly. We save the rules\n /// for anonymous boxes separately, so we resolve them as precomputed\n /// pseudos.\n ///\n /// We resolve the others lazily, see `Servo_ResolvePseudoStyle`.\n pub fn cascade_type(&self) -> PseudoElementCascadeType {\n if self.is_eager() {\n debug_assert!(!self.is_anon_box());\n return PseudoElementCascadeType::Eager;\n }\n\n if self.is_precomputed() {\n return PseudoElementCascadeType::Precomputed;\n }\n\n PseudoElementCascadeType::Lazy\n }\n\n /// Returns an index of the pseudo-element.\n #[inline]\n pub fn index(&self) -> usize {\n self.discriminant() as usize\n }\n\n #[inline]\n fn discriminant(&self) -> u8 {\n // SAFETY: #[repr(u8) guarantees this, see comments in\n // https://doc.rust-lang.org/std/mem/fn.discriminant.html\n unsafe { *(self as *const _ as *const u8) }\n }\n\n /// Whether this pseudo-element is an unknown Webkit-prefixed pseudo-element.\n #[inline]\n pub fn is_unknown_webkit_pseudo_element(&self) -> bool {\n matches!(*self, PseudoElement::UnknownWebkit(..))\n }\n\n /// Whether this pseudo-element is an anonymous box.\n #[inline]\n pub fn is_anon_box(&self) -> bool {\n self.flags().intersects(PseudoStyleTypeFlags::IS_ANON_BOX)\n }\n\n /// Whether this pseudo-element is eagerly-cascaded.\n #[inline]\n pub fn is_eager(&self) -> bool {\n self.flags().intersects(PseudoStyleTypeFlags::IS_EAGER)\n }\n\n /// Gets the canonical index of this eagerly-cascaded pseudo-element.\n #[inline]\n pub fn eager_index(&self) -> usize {\n EAGER_PSEUDOS\n .iter()\n .position(|p| p == self)\n .expect(\"Not an eager pseudo\")\n }\n\n /// Creates a pseudo-element from an eager index.\n #[inline]\n pub fn from_eager_index(i: usize) -> Self {\n EAGER_PSEUDOS[i].clone()\n }\n\n /// Whether animations for the current pseudo element are stored in the\n /// parent element.\n #[inline]\n pub fn animations_stored_in_parent(&self) -> bool {\n matches!(\n *self,\n Self::Before | Self::After | Self::Marker | Self::Backdrop\n )\n }\n\n /// Whether this pseudo-element is the ::before pseudo.\n #[inline]\n pub fn is_before(&self) -> bool {\n *self == PseudoElement::Before\n }\n\n /// Whether this pseudo-element is the ::after pseudo.\n #[inline]\n pub fn is_after(&self) -> bool {\n *self == PseudoElement::After\n }\n\n /// Whether this pseudo-element is the ::marker pseudo.\n #[inline]\n pub fn is_marker(&self) -> bool {\n *self == PseudoElement::Marker\n }\n\n /// Whether this pseudo-element is the ::selection pseudo.\n #[inline]\n pub fn is_selection(&self) -> bool {\n *self == PseudoElement::Selection\n }\n\n /// Whether this pseudo-element is ::first-letter.\n #[inline]\n pub fn is_first_letter(&self) -> bool {\n *self == PseudoElement::FirstLetter\n }\n\n /// Whether this pseudo-element is ::first-line.\n #[inline]\n pub fn is_first_line(&self) -> bool {\n *self == PseudoElement::FirstLine\n }\n\n /// Whether this pseudo-element is lazily-cascaded.\n #[inline]\n pub fn is_lazy(&self) -> bool {\n !self.is_eager() && !self.is_precomputed()\n }\n\n /// The identifier of the highlight this pseudo-element represents.\n pub fn highlight_name(&self) -> Option<&AtomIdent> {\n match *self {\n Self::Highlight(ref name) => Some(name),\n _ => None,\n }\n }\n\n /// Whether this pseudo-element is the ::highlight pseudo.\n pub fn is_highlight(&self) -> bool {\n matches!(*self, Self::Highlight(_))\n }\n\n /// Whether this pseudo-element is the ::target-text pseudo.\n #[inline]\n pub fn is_target_text(&self) -> bool {\n *self == PseudoElement::TargetText\n }\n\n /// Whether this is a highlight pseudo-element that is styled lazily during\n /// painting rather than during the restyle traversal. These pseudos need\n /// explicit repaint triggering when their styles change.\n #[inline]\n pub fn is_lazy_painted_highlight_pseudo(&self) -> bool {\n self.is_selection() || self.is_highlight() || self.is_target_text()\n }\n\n /// Whether this pseudo-element is a named view transition pseudo-element.\n pub fn is_named_view_transition(&self) -> bool {\n matches!(\n *self,\n Self::ViewTransitionGroup(..)\n | Self::ViewTransitionImagePair(..)\n | Self::ViewTransitionOld(..)\n | Self::ViewTransitionNew(..)\n )\n }\n\n /// The count we contribute to the specificity from this pseudo-element.\n pub fn specificity_count(&self) -> u32 {\n match *self {\n Self::ViewTransitionGroup(ref name_and_class)\n | Self::ViewTransitionImagePair(ref name_and_class)\n | Self::ViewTransitionOld(ref name_and_class)\n | Self::ViewTransitionNew(ref name_and_class) => {\n // The specificity of a named view transition pseudo-element selector with either:\n // 1. a with a ; or\n // 2. a with at least one ,\n // is equivalent to a type selector.\n //\n // The specificity of a named view transition pseudo-element selector with a `*`\n // argument and with an empty is zero.\n // https://drafts.csswg.org/css-view-transitions-2/#pseudo-element-class-additions\n (name_and_class.name() != &atom!(\"*\") || !name_and_class.classes().is_empty())\n as u32\n },\n _ => 1,\n }\n }\n\n /// Whether this pseudo-element supports user action selectors.\n pub fn supports_user_action_state(&self) -> bool {\n self.flags()\n .intersects(PseudoStyleTypeFlags::SUPPORTS_USER_ACTION_STATE)\n }\n\n /// Whether this pseudo-element is enabled for all content.\n pub fn enabled_in_content(&self) -> bool {\n Self::type_enabled_in_content(self.pseudo_type())\n }\n\n /// Whether this pseudo is enabled explicitly in UA sheets.\n pub fn enabled_in_ua_sheets(&self) -> bool {\n self.flags().intersects(PseudoStyleTypeFlags::ENABLED_IN_UA)\n }\n\n /// Whether this pseudo is enabled explicitly in chrome sheets.\n pub fn enabled_in_chrome(&self) -> bool {\n self.flags()\n .intersects(PseudoStyleTypeFlags::ENABLED_IN_CHROME)\n }\n\n /// Whether this pseudo-element skips flex/grid container display-based\n /// fixup.\n #[inline]\n pub fn skip_item_display_fixup(&self) -> bool {\n !self\n .flags()\n .intersects(PseudoStyleTypeFlags::IS_FLEX_OR_GRID_ITEM)\n }\n\n /// Whether this pseudo-element is precomputed.\n #[inline]\n pub fn is_precomputed(&self) -> bool {\n self.is_anon_box()\n }\n\n /// Property flag that properties must have to apply to this pseudo-element.\n #[inline]\n pub fn property_restriction(&self) -> Option {\n Some(match *self {\n PseudoElement::FirstLetter => PropertyFlags::APPLIES_TO_FIRST_LETTER,\n PseudoElement::FirstLine => PropertyFlags::APPLIES_TO_FIRST_LINE,\n PseudoElement::Placeholder => PropertyFlags::APPLIES_TO_PLACEHOLDER,\n PseudoElement::Cue => PropertyFlags::APPLIES_TO_CUE,\n PseudoElement::Marker => PropertyFlags::APPLIES_TO_MARKER,\n _ => return None,\n })\n }\n\n /// Whether this pseudo-element should actually exist if it has\n /// the given styles.\n pub fn should_exist(&self, style: &ComputedValues) -> bool {\n debug_assert!(self.is_eager());\n\n if style.get_box().clone_display() == Display::None {\n return false;\n }\n\n if self.is_before_or_after() && style.ineffective_content_property() {\n return false;\n }\n\n true\n }\n\n /// Parse the pseudo-element string without the check of enabled state. This may includes\n /// all possible PseudoElement, including tree pseudo-elements and anonymous box.\n // TODO: Bug 1845712. Merge this with the pseudo element part in parse_one_simple_selector().\n pub fn parse_ignore_enabled_state<'i, 't>(\n input: &mut Parser<'i, 't>,\n ) -> Result> {\n use crate::gecko::selector_parser;\n use cssparser::Token;\n use selectors::parser::{is_css2_pseudo_element, SelectorParseErrorKind};\n use style_traits::StyleParseErrorKind;\n\n // The pseudo-element string should start with ':'.\n input.expect_colon()?;\n\n let location = input.current_source_location();\n let next = input.next_including_whitespace()?;\n if !matches!(next, Token::Colon) {\n // Parse a CSS2 pseudo-element.\n let name = match next {\n Token::Ident(name) if is_css2_pseudo_element(&name) => name,\n _ => return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError)),\n };\n return PseudoElement::from_slice(&name, false).ok_or(location.new_custom_error(\n SelectorParseErrorKind::UnsupportedPseudoClassOrElement(name.clone()),\n ));\n }\n\n // Now we have double colons, so check the following tokens.\n match input.next_including_whitespace()?.clone() {\n Token::Ident(name) => {\n // We don't need to parse unknown ::-webkit-* pseudo-elements in this function.\n PseudoElement::from_slice(&name, false).ok_or(input.new_custom_error(\n SelectorParseErrorKind::UnsupportedPseudoClassOrElement(name),\n ))\n },\n Token::Function(name) => {\n // Note: ::slotted() and ::part() are not accepted in getComputedStyle().\n // https://drafts.csswg.org/cssom/#dom-window-getcomputedstyle\n input.parse_nested_block(|input| {\n selector_parser::parse_functional_pseudo_element_with_name(\n &name,\n input,\n Target::Cssom,\n )\n })\n },\n t => return Err(input.new_unexpected_token_error(t)),\n }\n }\n\n /// Returns true if this pseudo-element matches its selector.\n pub fn matches_named_view_transition_pseudo_element(\n &self,\n selector: &Self,\n element: &super::wrapper::GeckoElement,\n ) -> bool {\n use crate::gecko_bindings::bindings;\n\n match (self, selector) {\n (\n &Self::ViewTransitionGroup(ref name),\n &Self::ViewTransitionGroup(ref s_name_class),\n )\n | (\n &Self::ViewTransitionImagePair(ref name),\n &Self::ViewTransitionImagePair(ref s_name_class),\n )\n | (&Self::ViewTransitionOld(ref name), &Self::ViewTransitionOld(ref s_name_class))\n | (&Self::ViewTransitionNew(ref name), &Self::ViewTransitionNew(ref s_name_class)) => {\n // Named view transition pseudos accept the universal selector as the name, so we\n // check it first.\n // https://drafts.csswg.org/css-view-transitions-1/#named-view-transition-pseudo\n let s_name = s_name_class.name();\n if s_name != name.name() && s_name != &atom!(\"*\") {\n return false;\n }\n\n // We have to check class list only when the name is matched and there are one or\n // more s.\n s_name_class.classes().is_empty()\n || unsafe {\n bindings::Gecko_MatchViewTransitionClass(\n element.0,\n s_name_class.name_and_classes(),\n )\n }\n },\n _ => false,\n }\n }\n}\n" }, { "path": "style/gecko/pseudo_element_definition.mako.rs", "content": "/* This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/. */\n\nuse crate::derives::*;\n\ntype AtomThinVec = thin_vec::ThinVec;\n\n/// Gecko's pseudo-element definition.\n///\n/// We intentionally double-box legacy ::-moz-tree pseudo-elements to keep the\n/// size of PseudoElement (and thus selector components) small.\n#[derive(Clone, Debug, Eq, Hash, MallocSizeOf, PartialEq, ToShmem)]\n#[repr(u8)]\npub enum PseudoElement {\n % for pseudo in PSEUDOS:\n /// ${pseudo.name}\n % if pseudo.argument:\n ${pseudo.capitalized}(${pseudo.argument}),\n % else:\n ${pseudo.capitalized},\n % endif\n % endfor\n /// ::-webkit-* that we don't recognize\n /// https://github.com/whatwg/compat/issues/103\n UnknownWebkit(Atom),\n}\n\n<% EAGER_PSEUDOS = list(filter(lambda p: getattr(p, 'is_eager', False), PSEUDOS)) %>\n\n/// The number of eager pseudo-elements.\npub const EAGER_PSEUDO_COUNT: usize = ${len(EAGER_PSEUDOS)};\n\n/// The number of all pseudo-elements.\npub const PSEUDO_COUNT: usize = ${len(PSEUDOS)};\n\n/// The list of eager pseudos.\npub const EAGER_PSEUDOS: [PseudoElement; EAGER_PSEUDO_COUNT] = [\n % for eager_pseudo in EAGER_PSEUDOS:\n PseudoElement::${eager_pseudo.capitalized},\n % endfor\n];\n\n<%def name=\"pseudo_element_variant(pseudo, arg='..')\">\\\nPseudoElement::${pseudo.capitalized}${\"({})\".format(arg) if pseudo.argument else \"\"}\\\n\n\nimpl PseudoElement {\n /// Whether this pseudo-element is tree pseudo-element.\n #[inline]\n pub fn is_tree_pseudo_element(&self) -> bool {\n match *self {\n % for pseudo in PSEUDOS:\n % if pseudo.name.startswith(\"-moz-tree-\"):\n ${pseudo_element_variant(pseudo)} => true,\n % endif\n % endfor\n _ => false,\n }\n }\n\n #[inline]\n fn flags_for_index(i: usize) -> PseudoStyleTypeFlags {\n static FLAGS: [PseudoStyleTypeFlags; PSEUDO_COUNT + 1] = [\n % for pseudo in PSEUDOS:\n PseudoStyleTypeFlags::from_bits_truncate(${' | '.join(f\"PseudoStyleTypeFlags::{flag}.bits()\" for flag in pseudo.flags())}),\n % endfor\n PseudoStyleTypeFlags::NONE, // :-webkit-*\n ];\n FLAGS[i]\n }\n\n /// Gets the flags associated to this pseudo-element or anon box.\n #[inline]\n pub fn flags(&self) -> PseudoStyleTypeFlags {\n Self::flags_for_index(self.index())\n }\n\n /// If this pseudo is pref-gated, returns the pref value, otherwise false.\n pub fn type_enabled_in_content(ty: PseudoStyleType) -> bool {\n let flags = Self::flags_for_index(ty as usize);\n // Common path, not enabled explicitly in UA sheets (note that chrome implies UA), and not\n // pref-gated.\n if !flags.intersects(PseudoStyleTypeFlags::ENABLED_IN_UA | PseudoStyleTypeFlags::ENABLED_BY_PREF) {\n return true;\n }\n if !flags.intersects(PseudoStyleTypeFlags::ENABLED_BY_PREF) {\n return false;\n }\n match ty {\n % for pseudo in PSEUDOS:\n % if pseudo.pref:\n PseudoStyleType::${pseudo.capitalized} => pref!(\"${pseudo.pref}\"),\n % endif\n % endfor\n _ => false,\n }\n }\n\n /// Construct a pseudo-element from a `PseudoStyleType`.\n #[inline]\n pub fn from_pseudo_type(type_: PseudoStyleType, functional_pseudo_parameter: Option) -> Option {\n match type_ {\n % for pseudo in PSEUDOS:\n % if not pseudo.argument:\n PseudoStyleType::${pseudo.capitalized} => {\n debug_assert!(functional_pseudo_parameter.is_none());\n Some(${pseudo_element_variant(pseudo)})\n },\n % elif pseudo.argument == \"AtomThinVec\":\n PseudoStyleType::${pseudo.capitalized} => {\n debug_assert!(functional_pseudo_parameter.is_none());\n Some(${pseudo_element_variant(pseudo, \"Default::default()\")})\n },\n % elif pseudo.argument == \"PtNameAndClassSelector\":\n PseudoStyleType::${pseudo.capitalized} => functional_pseudo_parameter.map(|p| {\n PseudoElement::${pseudo.capitalized}(PtNameAndClassSelector::from_name(p.0))\n }),\n % else:\n <% assert pseudo.argument == \"AtomIdent\", f\"Unhandled argument type {pseudo.argument}\" %>\n PseudoStyleType::${pseudo.capitalized} => {\n functional_pseudo_parameter.map(PseudoElement::${pseudo.capitalized})\n },\n % endif\n % endfor\n _ => None,\n }\n }\n\n /// Construct a `PseudoStyleType`.\n #[inline]\n pub fn pseudo_type(&self) -> PseudoStyleType {\n // SAFETY: PseudoStyleType has the same variants as PseudoElement\n unsafe { std::mem::transmute::(self.discriminant()) }\n }\n\n /// Returns the relevant PseudoStyleType, and an atom as an argument, if any.\n /// FIXME: we probably have to return the arguments of -moz-tree. However, they are multiple\n /// names, so we skip them for now (until we really need them).\n #[inline]\n pub fn pseudo_type_and_argument(&self) -> (PseudoStyleType, Option<&Atom>) {\n let ty = self.pseudo_type();\n let arg = match *self {\n % for pseudo in PSEUDOS:\n % if pseudo.argument == \"PtNameAndClassSelector\":\n PseudoElement::${pseudo.capitalized}(ref val) => Some(val.name()),\n % elif pseudo.argument == \"AtomIdent\":\n PseudoElement::${pseudo.capitalized}(ref val) => Some(&val.0),\n % endif\n % endfor\n _ => None,\n };\n (ty, arg)\n }\n\n /// Get the argument list of a tree pseudo-element.\n #[inline]\n pub fn tree_pseudo_args(&self) -> &[Atom] {\n match *self {\n % for pseudo in PSEUDOS:\n % if pseudo.name.startswith(\"-moz-tree-\"):\n PseudoElement::${pseudo.capitalized}(ref args) => &args,\n % endif\n % endfor\n _ => &[],\n }\n }\n\n /// Constructs a pseudo-element from a string of text.\n ///\n /// Returns `None` if the pseudo-element is not recognised.\n #[inline]\n pub fn from_slice(name: &str, allow_unkown_webkit: bool) -> Option {\n // We don't need to support tree pseudos because functional\n // pseudo-elements needs arguments, and thus should be created\n // via other methods.\n cssparser::ascii_case_insensitive_phf_map! {\n pseudo -> PseudoElement = {\n % for pseudo in PSEUDOS:\n % if not pseudo.argument:\n \"${pseudo.name}\" => ${pseudo_element_variant(pseudo)},\n % endif\n % endfor\n // Alias some legacy prefixed pseudos to their standardized name at parse time:\n \"-moz-selection\" => PseudoElement::Selection,\n \"-moz-placeholder\" => PseudoElement::Placeholder,\n \"-moz-list-bullet\" => PseudoElement::Marker,\n \"-moz-list-number\" => PseudoElement::Marker,\n }\n }\n if let Some(p) = pseudo::get(name) {\n return Some(p.clone());\n }\n if starts_with_ignore_ascii_case(name, \"-moz-tree-\") {\n return PseudoElement::tree_pseudo_element(name, Default::default())\n }\n const WEBKIT_PREFIX: &str = \"-webkit-\";\n if allow_unkown_webkit && starts_with_ignore_ascii_case(name, WEBKIT_PREFIX) {\n let part = string_as_ascii_lowercase(&name[WEBKIT_PREFIX.len()..]);\n return Some(PseudoElement::UnknownWebkit(part.into()));\n }\n None\n }\n\n /// Constructs a tree pseudo-element from the given name and arguments.\n /// \"name\" must start with \"-moz-tree-\".\n ///\n /// Returns `None` if the pseudo-element is not recognized.\n #[inline]\n pub fn tree_pseudo_element(name: &str, args: thin_vec::ThinVec) -> Option {\n debug_assert!(starts_with_ignore_ascii_case(name, \"-moz-tree-\"));\n let tree_part = &name[10..];\n % for pseudo in PSEUDOS:\n % if pseudo.name.startswith(\"-moz-tree-\"):\n if tree_part.eq_ignore_ascii_case(\"${pseudo.name[10:]}\") {\n return Some(${pseudo_element_variant(pseudo, \"args\")});\n }\n % endif\n % endfor\n None\n }\n\n /// Returns true if this pseudo-element matches the given selector.\n pub fn matches(\n &self,\n pseudo_selector: &PseudoElement,\n element: &super::wrapper::GeckoElement,\n ) -> bool {\n if *self == *pseudo_selector {\n return true;\n }\n\n if std::mem::discriminant(self) != std::mem::discriminant(pseudo_selector) {\n return false;\n }\n\n // Check named view transition pseudo-elements.\n self.matches_named_view_transition_pseudo_element(pseudo_selector, element)\n }\n}\n\nimpl ToCss for PseudoElement {\n fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {\n match *self {\n % for pseudo in PSEUDOS:\n % if pseudo.argument == \"AtomThinVec\":\n ${pseudo_element_variant(pseudo, \"ref args\")} => {\n dest.write_str(\"::${pseudo.name}\")?;\n let mut iter = args.iter();\n if let Some(first) = iter.next() {\n dest.write_char('(')?;\n serialize_atom_identifier(&first, dest)?;\n for item in iter {\n dest.write_str(\", \")?;\n serialize_atom_identifier(item, dest)?;\n }\n dest.write_char(')')?;\n }\n Ok(())\n },\n % elif pseudo.argument:\n PseudoElement::${pseudo.capitalized}(ref arg) => {\n dest.write_str(\"::${pseudo.name}(\")?;\n arg.to_css(dest)?;\n dest.write_char(')')\n }\n % else:\n ${pseudo_element_variant(pseudo)} => dest.write_str(\"::${pseudo.name}\"),\n % endif\n % endfor\n PseudoElement::UnknownWebkit(ref atom) => {\n dest.write_str(\"::-webkit-\")?;\n serialize_atom_identifier(atom, dest)\n },\n }\n }\n}\n" }, { "path": "style/gecko/pseudo_elements.py", "content": "#!/usr/bin/env python\n\n# This Source Code Form is subject to the terms of the Mozilla Public\n# License, v. 2.0. If a copy of the MPL was not distributed with this\n# file, You can obtain one at https://mozilla.org/MPL/2.0/.\n\nimport os\nimport sys\n\nimport toml\n\nTHIS_DIR = os.path.dirname(__file__)\nsys.path.insert(0, os.path.join(os.path.dirname(THIS_DIR), \"properties\"))\n\nimport data\n\n\nclass Pseudo(object):\n def __init__(self, name, argument, enabled_in, pref):\n self.name = name\n self.camel = data.to_camel_case(name)\n self.capitalized = self.camel[0].upper() + self.camel[1:]\n self.argument = argument\n self.enabled_in = enabled_in\n self.pref = pref\n\n def is_pseudo_element(self):\n return isinstance(self, PseudoElement)\n\n def is_anon_box(self):\n return isinstance(self, AnonBox)\n\n def is_non_inheriting_anon_box(self):\n return isinstance(self, AnonBox) and not self.inherits\n\n def is_inheriting_anon_box(self):\n return isinstance(self, AnonBox) and self.inherits\n\n def flags(self):\n flags = []\n if self.enabled_in == \"ua\":\n flags.append(\"ENABLED_IN_UA\")\n elif self.enabled_in == \"chrome\":\n flags.append(\"ENABLED_IN_UA\")\n flags.append(\"ENABLED_IN_CHROME\")\n if self.pref:\n flags.append(\"ENABLED_BY_PREF\")\n if isinstance(self, PseudoElement):\n flags.append(\"IS_PSEUDO_ELEMENT\")\n if self.is_css2:\n flags.append(\"IS_CSS2\")\n if self.is_eager:\n flags.append(\"IS_EAGER\")\n if self.is_js_created_nac:\n flags.append(\"IS_JS_CREATED_NAC\")\n if self.is_flex_or_grid_item:\n flags.append(\"IS_FLEX_OR_GRID_ITEM\")\n if self.is_element_backed:\n flags.append(\"IS_ELEMENT_BACKED\")\n if self.is_tree_abiding:\n flags.append(\"IS_TREE_ABIDING\")\n if self.parses_as_element_backed:\n flags.append(\"PARSES_AS_ELEMENT_BACKED\")\n if self.supports_user_action_state:\n flags.append(\"SUPPORTS_USER_ACTION_STATE\")\n if isinstance(self, AnonBox):\n if self.inherits:\n flags.append(\"IS_INHERITING_ANON_BOX\")\n else:\n flags.append(\"IS_NON_INHERITING_ANON_BOX\")\n if self.wrapper:\n flags.append(\"IS_WRAPPER_ANON_BOX\")\n return flags\n\n\nclass AnonBox(Pseudo):\n def __init__(self, name, wrapper=False, inherits=True):\n super().__init__(name, argument=None, enabled_in=\"ua\", pref=None)\n self.wrapper = wrapper\n self.inherits = inherits\n\n\nclass PseudoElement(Pseudo):\n def __init__(\n self,\n name,\n enabled_in=\"content\",\n is_css2=False,\n is_eager=False,\n is_js_created_nac=False,\n is_flex_or_grid_item=False,\n is_element_backed=False,\n is_tree_abiding=False,\n parses_as_element_backed=None,\n supports_user_action_state=False,\n pref=None,\n argument=None,\n ):\n super().__init__(name, argument=argument, enabled_in=enabled_in, pref=pref)\n self.is_css2 = is_css2\n self.is_eager = is_eager\n self.is_js_created_nac = is_js_created_nac\n self.is_flex_or_grid_item = is_flex_or_grid_item\n self.is_element_backed = is_element_backed\n self.is_tree_abiding = is_element_backed or is_tree_abiding\n self.parses_as_element_backed = (\n parses_as_element_backed\n if parses_as_element_backed is not None\n else is_element_backed\n )\n self.supports_user_action_state = supports_user_action_state\n\n\nclass PseudoElementData:\n def __init__(self):\n this_dir = os.path.dirname(__file__)\n pseudo_elements_toml = os.path.join(this_dir, \"pseudo_elements.toml\")\n anon_boxes_toml = os.path.join(this_dir, \"anon_boxes.toml\")\n self.anon_boxes = sorted(\n (\n AnonBox(name, **val)\n for name, val in toml.loads(open(anon_boxes_toml).read()).items()\n ),\n key=lambda n: n.inherits,\n )\n self.pseudo_elements = [\n PseudoElement(name, **val)\n for name, val in toml.loads(open(pseudo_elements_toml).read()).items()\n ]\n self.path_dependencies = [pseudo_elements_toml, anon_boxes_toml]\n\n def all_pseudos(self):\n return self.anon_boxes + self.pseudo_elements\n" }, { "path": "style/gecko/pseudo_elements.toml", "content": "# This Source Code Form is subject to the terms of the Mozilla Public\n# License, v. 2.0. If a copy of the MPL was not distributed with this\n# file, You can obtain one at http://mozilla.org/MPL/2.0/.\n#\n# This file contains the list of support CSS pseudo-elements and some flags.\n#\n# Each pseudo element has its own section, with the following keys:\n#\n# enabled_in - Same semantics as longhands.toml\n# is_css2 - Default false, whether this is a css2 pseudo-element, and can be\n# parsed only with one colon.\n# is_eager - Whether the pseudo-element is eagerly cascaded by the style\n# system during traversal. This should generally only be used for\n# pseudo-elements that apply to most elements.\n# is_js_created_nac - True if this pseudo-element can be created by JS.\n# is_flex_or_grid_item - True if display item fixup for flex / grid should\n# happen for this pseudo\n# is_element_backed - whether this is an element-backed pseudo-element\n# https://drafts.csswg.org/css-pseudo-4/#element-like\n# supports_user_action_state - true if this pseudo supports :hover etc.\n# argument - If provided, the argument this functional pseudo takes.\n# pref - Same semantics as gecko_pref in longhands.toml\n#\n# When adding a pseudo-element, you also need to add the relevant atom to\n# StaticAtoms.py, with the camel-case name of the pseudo-element.\n[after]\nis_css2 = true\nis_eager = true\nis_flex_or_grid_item = true\nis_tree_abiding = true\n[before]\nis_css2 = true\nis_eager = true\nis_flex_or_grid_item = true\nis_tree_abiding = true\n[marker]\nis_tree_abiding = true\n[backdrop]\n[cue]\nis_js_created_nac = true\n[first-letter]\nis_css2 = true\nis_eager = true\n[first-line]\nis_css2 = true\nis_eager = true\n[highlight]\nargument = \"AtomIdent\"\n[selection]\n[target-text]\n[view-transition]\nenabled_in = \"ua\"\npref = \"dom.viewTransitions.enabled\"\n[view-transition-group]\nenabled_in = \"ua\"\npref = \"dom.viewTransitions.enabled\"\nargument = \"PtNameAndClassSelector\"\nis_element_backed = true\n[view-transition-image-pair]\nenabled_in = \"ua\"\npref = \"dom.viewTransitions.enabled\"\nis_element_backed = true\nargument = \"PtNameAndClassSelector\"\n[view-transition-old]\nenabled_in = \"ua\"\npref = \"dom.viewTransitions.enabled\"\nis_element_backed = true\nargument = \"PtNameAndClassSelector\"\n[view-transition-new]\nenabled_in = \"ua\"\npref = \"dom.viewTransitions.enabled\"\nis_element_backed = true\nargument = \"PtNameAndClassSelector\"\n# The internal implementation usage for View transition to create the snapshot\n# containing block concept.\n[-moz-snapshot-containing-block]\nenabled_in = \"ua\"\n[picker]\nenabled_in = \"ua\"\npref = \"dom.select.customizable_select.enabled\"\nargument = \"AtomIdent\"\nis_element_backed = true\n\n# HTML5 Forms pseudo elements\n[-moz-number-spin-box]\nsupports_user_action_state = true\nenabled_in = \"chrome\"\n[-moz-number-spin-down]\nsupports_user_action_state = true\nenabled_in = \"chrome\"\n[-moz-number-spin-up]\nsupports_user_action_state = true\nenabled_in = \"chrome\"\n[-moz-search-clear-button]\nsupports_user_action_state = true\nenabled_in = \"chrome\"\n# The selected label of a \n[picker-icon]\nenabled_in = \"chrome\"\npref = \"dom.select.customizable_select.enabled\"\nis_element_backed = true\n# We represent ::picker-icon with a real element, but per spec it should parse\n# as a regular generated content pseudo-element.\nparses_as_element_backed = false\n[-moz-progress-bar]\nsupports_user_action_state = true\n[-moz-range-track]\nsupports_user_action_state = true\n[-moz-range-progress]\nsupports_user_action_state = true\n[-moz-range-thumb]\nsupports_user_action_state = true\n[-moz-meter-bar]\nsupports_user_action_state = true\n[placeholder]\nsupports_user_action_state = true\nis_element_backed = true\nparses_as_element_backed = false\n[-moz-color-swatch]\nsupports_user_action_state = true\n# The root of the text value anonymous content inside an or