script: Move HTML DOM interfaces to script/dom/html/ (#39046)

See #38901.

Testing: Refactor
Fixes: Partially #38901

Signed-off-by: Ashwin Naren <arihant2math@gmail.com>

components/script/dom/html/htmlselectelement.rs

@@ -0,0 +1,824 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+use std::default::Default;
+use std::iter;
+
+use dom_struct::dom_struct;
+use embedder_traits::{EmbedderMsg, FormControl as EmbedderFormControl};
+use embedder_traits::{SelectElementOption, SelectElementOptionOrOptgroup};
+use euclid::{Point2D, Rect, Size2D};
+use html5ever::{LocalName, Prefix, local_name};
+use js::rust::HandleObject;
+use style::attr::AttrValue;
+use stylo_dom::ElementState;
+use webrender_api::units::DeviceIntRect;
+use base::generic_channel;
+use crate::dom::bindings::refcounted::Trusted;
+use crate::dom::event::{EventBubbles, EventCancelable, EventComposed};
+use crate::dom::bindings::codegen::GenericBindings::HTMLOptGroupElementBinding::HTMLOptGroupElement_Binding::HTMLOptGroupElementMethods;
+use crate::dom::activation::Activatable;
+use crate::dom::attr::Attr;
+use crate::dom::bindings::cell::{DomRefCell, Ref};
+use crate::dom::bindings::codegen::Bindings::ElementBinding::ElementMethods;
+use crate::dom::bindings::codegen::Bindings::HTMLCollectionBinding::HTMLCollectionMethods;
+use crate::dom::bindings::codegen::Bindings::HTMLOptionElementBinding::HTMLOptionElementMethods;
+use crate::dom::bindings::codegen::Bindings::HTMLOptionsCollectionBinding::HTMLOptionsCollectionMethods;
+use crate::dom::bindings::codegen::Bindings::HTMLSelectElementBinding::HTMLSelectElementMethods;
+use crate::dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
+use crate::dom::bindings::codegen::GenericBindings::CharacterDataBinding::CharacterData_Binding::CharacterDataMethods;
+use crate::dom::bindings::codegen::UnionTypes::{
+    HTMLElementOrLong, HTMLOptionElementOrHTMLOptGroupElement,
+};
+use crate::dom::bindings::error::ErrorResult;
+use crate::dom::bindings::inheritance::Castable;
+use crate::dom::bindings::root::{Dom, DomRoot, MutNullableDom};
+use crate::dom::bindings::str::DOMString;
+use crate::dom::characterdata::CharacterData;
+use crate::dom::document::Document;
+use crate::dom::element::{AttributeMutation, Element};
+use crate::dom::event::Event;
+use crate::dom::eventtarget::EventTarget;
+use crate::dom::html::htmlcollection::CollectionFilter;
+use crate::dom::html::htmldivelement::HTMLDivElement;
+use crate::dom::html::htmlelement::HTMLElement;
+use crate::dom::html::htmlfieldsetelement::HTMLFieldSetElement;
+use crate::dom::html::htmlformelement::{FormControl, FormDatum, FormDatumValue, HTMLFormElement};
+use crate::dom::html::htmloptgroupelement::HTMLOptGroupElement;
+use crate::dom::html::htmloptionelement::HTMLOptionElement;
+use crate::dom::html::htmloptionscollection::HTMLOptionsCollection;
+use crate::dom::node::{BindContext, ChildrenMutation, Node, NodeTraits, UnbindContext};
+use crate::dom::nodelist::NodeList;
+use crate::dom::text::Text;
+use crate::dom::validation::{Validatable, is_barred_by_datalist_ancestor};
+use crate::dom::validitystate::{ValidationFlags, ValidityState};
+use crate::dom::virtualmethods::VirtualMethods;
+use crate::script_runtime::CanGc;
+
+const DEFAULT_SELECT_SIZE: u32 = 0;
+
+const SELECT_BOX_STYLE: &str = "
+    display: flex;
+    align-items: center;
+    height: 100%;
+";
+
+const TEXT_CONTAINER_STYLE: &str = "flex: 1;";
+
+const CHEVRON_CONTAINER_STYLE: &str = "
+    font-size: 16px;
+    margin: 4px;
+";
+
+#[derive(JSTraceable, MallocSizeOf)]
+struct OptionsFilter;
+impl CollectionFilter for OptionsFilter {
+    fn filter<'a>(&self, elem: &'a Element, root: &'a Node) -> bool {
+        if !elem.is::<HTMLOptionElement>() {
+            return false;
+        }
+
+        let node = elem.upcast::<Node>();
+        if root.is_parent_of(node) {
+            return true;
+        }
+
+        match node.GetParentNode() {
+            Some(optgroup) => optgroup.is::<HTMLOptGroupElement>() && root.is_parent_of(&optgroup),
+            None => false,
+        }
+    }
+}
+
+#[dom_struct]
+pub(crate) struct HTMLSelectElement {
+    htmlelement: HTMLElement,
+    options: MutNullableDom<HTMLOptionsCollection>,
+    form_owner: MutNullableDom<HTMLFormElement>,
+    labels_node_list: MutNullableDom<NodeList>,
+    validity_state: MutNullableDom<ValidityState>,
+    shadow_tree: DomRefCell<Option<ShadowTree>>,
+}
+
+/// Holds handles to all elements in the UA shadow tree
+#[derive(Clone, JSTraceable, MallocSizeOf)]
+#[cfg_attr(crown, crown::unrooted_must_root_lint::must_root)]
+struct ShadowTree {
+    selected_option: Dom<Text>,
+}
+
+impl HTMLSelectElement {
+    fn new_inherited(
+        local_name: LocalName,
+        prefix: Option<Prefix>,
+        document: &Document,
+    ) -> HTMLSelectElement {
+        HTMLSelectElement {
+            htmlelement: HTMLElement::new_inherited_with_state(
+                ElementState::ENABLED | ElementState::VALID,
+                local_name,
+                prefix,
+                document,
+            ),
+            options: Default::default(),
+            form_owner: Default::default(),
+            labels_node_list: Default::default(),
+            validity_state: Default::default(),
+            shadow_tree: Default::default(),
+        }
+    }
+
+    #[cfg_attr(crown, allow(crown::unrooted_must_root))]
+    pub(crate) fn new(
+        local_name: LocalName,
+        prefix: Option<Prefix>,
+        document: &Document,
+        proto: Option<HandleObject>,
+        can_gc: CanGc,
+    ) -> DomRoot<HTMLSelectElement> {
+        let n = Node::reflect_node_with_proto(
+            Box::new(HTMLSelectElement::new_inherited(
+                local_name, prefix, document,
+            )),
+            document,
+            proto,
+            can_gc,
+        );
+
+        n.upcast::<Node>().set_weird_parser_insertion_mode();
+        n
+    }
+
+    /// <https://html.spec.whatwg.org/multipage/#concept-select-option-list>
+    pub(crate) fn list_of_options(
+        &self,
+    ) -> impl Iterator<Item = DomRoot<HTMLOptionElement>> + use<'_> {
+        self.upcast::<Node>().children().flat_map(|node| {
+            if node.is::<HTMLOptionElement>() {
+                let node = DomRoot::downcast::<HTMLOptionElement>(node).unwrap();
+                Choice3::First(iter::once(node))
+            } else if node.is::<HTMLOptGroupElement>() {
+                Choice3::Second(node.children().filter_map(DomRoot::downcast))
+            } else {
+                Choice3::Third(iter::empty())
+            }
+        })
+    }
+
+    // https://html.spec.whatwg.org/multipage/#placeholder-label-option
+    fn get_placeholder_label_option(&self) -> Option<DomRoot<HTMLOptionElement>> {
+        if self.Required() && !self.Multiple() && self.display_size() == 1 {
+            self.list_of_options().next().filter(|node| {
+                let parent = node.upcast::<Node>().GetParentNode();
+                node.Value().is_empty() && parent.as_deref() == Some(self.upcast())
+            })
+        } else {
+            None
+        }
+    }
+
+    // https://html.spec.whatwg.org/multipage/#the-select-element:concept-form-reset-control
+    pub(crate) fn reset(&self) {
+        for opt in self.list_of_options() {
+            opt.set_selectedness(opt.DefaultSelected());
+            opt.set_dirtiness(false);
+        }
+        self.ask_for_reset();
+    }
+
+    // https://html.spec.whatwg.org/multipage/#ask-for-a-reset
+    pub(crate) fn ask_for_reset(&self) {
+        if self.Multiple() {
+            return;
+        }
+
+        let mut first_enabled: Option<DomRoot<HTMLOptionElement>> = None;
+        let mut last_selected: Option<DomRoot<HTMLOptionElement>> = None;
+
+        for opt in self.list_of_options() {
+            if opt.Selected() {
+                opt.set_selectedness(false);
+                last_selected = Some(DomRoot::from_ref(&opt));
+            }
+            let element = opt.upcast::<Element>();
+            if first_enabled.is_none() && !element.disabled_state() {
+                first_enabled = Some(DomRoot::from_ref(&opt));
+            }
+        }
+
+        if let Some(last_selected) = last_selected {
+            last_selected.set_selectedness(true);
+        } else if self.display_size() == 1 {
+            if let Some(first_enabled) = first_enabled {
+                first_enabled.set_selectedness(true);
+            }
+        }
+    }
+
+    pub(crate) fn push_form_data(&self, data_set: &mut Vec<FormDatum>) {
+        if self.Name().is_empty() {
+            return;
+        }
+        for opt in self.list_of_options() {
+            let element = opt.upcast::<Element>();
+            if opt.Selected() && element.enabled_state() {
+                data_set.push(FormDatum {
+                    ty: self.Type(),
+                    name: self.Name(),
+                    value: FormDatumValue::String(opt.Value()),
+                });
+            }
+        }
+    }
+
+    // https://html.spec.whatwg.org/multipage/#concept-select-pick
+    pub(crate) fn pick_option(&self, picked: &HTMLOptionElement) {
+        if !self.Multiple() {
+            let picked = picked.upcast();
+            for opt in self.list_of_options() {
+                if opt.upcast::<HTMLElement>() != picked {
+                    opt.set_selectedness(false);
+                }
+            }
+        }
+    }
+
+    // https://html.spec.whatwg.org/multipage/#concept-select-size
+    fn display_size(&self) -> u32 {
+        if self.Size() == 0 {
+            if self.Multiple() { 4 } else { 1 }
+        } else {
+            self.Size()
+        }
+    }
+
+    fn create_shadow_tree(&self, can_gc: CanGc) {
+        let document = self.owner_document();
+        let root = self.upcast::<Element>().attach_ua_shadow_root(true, can_gc);
+
+        let select_box = HTMLDivElement::new(local_name!("div"), None, &document, None, can_gc);
+        select_box.upcast::<Element>().set_string_attribute(
+            &local_name!("style"),
+            SELECT_BOX_STYLE.into(),
+            can_gc,
+        );
+
+        let text_container = HTMLDivElement::new(local_name!("div"), None, &document, None, can_gc);
+        text_container.upcast::<Element>().set_string_attribute(
+            &local_name!("style"),
+            TEXT_CONTAINER_STYLE.into(),
+            can_gc,
+        );
+        select_box
+            .upcast::<Node>()
+            .AppendChild(text_container.upcast::<Node>(), can_gc)
+            .unwrap();
+
+        let text = Text::new(DOMString::new(), &document, can_gc);
+        let _ = self.shadow_tree.borrow_mut().insert(ShadowTree {
+            selected_option: text.as_traced(),
+        });
+        text_container
+            .upcast::<Node>()
+            .AppendChild(text.upcast::<Node>(), can_gc)
+            .unwrap();
+
+        let chevron_container =
+            HTMLDivElement::new(local_name!("div"), None, &document, None, can_gc);
+        chevron_container.upcast::<Element>().set_string_attribute(
+            &local_name!("style"),
+            CHEVRON_CONTAINER_STYLE.into(),
+            can_gc,
+        );
+        chevron_container
+            .upcast::<Node>()
+            .set_text_content_for_element(Some("▾".into()), can_gc);
+        select_box
+            .upcast::<Node>()
+            .AppendChild(chevron_container.upcast::<Node>(), can_gc)
+            .unwrap();
+
+        root.upcast::<Node>()
+            .AppendChild(select_box.upcast::<Node>(), can_gc)
+            .unwrap();
+    }
+
+    fn shadow_tree(&self, can_gc: CanGc) -> Ref<'_, ShadowTree> {
+        if !self.upcast::<Element>().is_shadow_host() {
+            self.create_shadow_tree(can_gc);
+        }
+
+        Ref::filter_map(self.shadow_tree.borrow(), Option::as_ref)
+            .ok()
+            .expect("UA shadow tree was not created")
+    }
+
+    pub(crate) fn update_shadow_tree(&self, can_gc: CanGc) {
+        let shadow_tree = self.shadow_tree(can_gc);
+
+        let selected_option_text = self
+            .selected_option()
+            .or_else(|| self.list_of_options().next())
+            .map(|option| option.displayed_label())
+            .unwrap_or_default();
+
+        // Replace newlines with whitespace, then collapse and trim whitespace
+        let displayed_text = itertools::join(selected_option_text.split_whitespace(), " ");
+
+        shadow_tree
+            .selected_option
+            .upcast::<CharacterData>()
+            .SetData(displayed_text.trim().into());
+    }
+
+    pub(crate) fn selected_option(&self) -> Option<DomRoot<HTMLOptionElement>> {
+        self.list_of_options()
+            .find(|opt_elem| opt_elem.Selected())
+            .or_else(|| self.list_of_options().next())
+    }
+
+    pub(crate) fn show_menu(&self) -> Option<usize> {
+        let (ipc_sender, ipc_receiver) =
+            generic_channel::channel().expect("Failed to create IPC channel!");
+
+        // Collect list of optgroups and options
+        let mut index = 0;
+        let mut embedder_option_from_option = |option: &HTMLOptionElement| {
+            let embedder_option = SelectElementOption {
+                id: index,
+                label: option.displayed_label().into(),
+                is_disabled: option.Disabled(),
+            };
+            index += 1;
+            embedder_option
+        };
+        let options = self
+            .upcast::<Node>()
+            .children()
+            .flat_map(|child| {
+                if let Some(option) = child.downcast::<HTMLOptionElement>() {
+                    return Some(embedder_option_from_option(option).into());
+                }
+
+                if let Some(optgroup) = child.downcast::<HTMLOptGroupElement>() {
+                    let options = optgroup
+                        .upcast::<Node>()
+                        .children()
+                        .flat_map(DomRoot::downcast::<HTMLOptionElement>)
+                        .map(|option| embedder_option_from_option(&option))
+                        .collect();
+                    let label = optgroup.Label().into();
+
+                    return Some(SelectElementOptionOrOptgroup::Optgroup { label, options });
+                }
+
+                None
+            })
+            .collect();
+
+        let rect = self.upcast::<Node>().border_box().unwrap_or_default();
+        let rect = Rect::new(
+            Point2D::new(rect.origin.x.to_px(), rect.origin.y.to_px()),
+            Size2D::new(rect.size.width.to_px(), rect.size.height.to_px()),
+        );
+
+        let selected_index = self.list_of_options().position(|option| option.Selected());
+
+        let document = self.owner_document();
+        document.send_to_embedder(EmbedderMsg::ShowFormControl(
+            document.webview_id(),
+            DeviceIntRect::from_untyped(&rect.to_box2d()),
+            EmbedderFormControl::SelectElement(options, selected_index, ipc_sender),
+        ));
+
+        let Ok(response) = ipc_receiver.recv() else {
+            log::error!("Failed to receive response");
+            return None;
+        };
+
+        response
+    }
+
+    /// <https://html.spec.whatwg.org/multipage/#send-select-update-notifications>
+    fn send_update_notifications(&self) {
+        // > When the user agent is to send select update notifications, queue an element task on the
+        // > user interaction task source given the select element to run these steps:
+        let this = Trusted::new(self);
+        self.owner_global()
+            .task_manager()
+            .user_interaction_task_source()
+            .queue(task!(send_select_update_notification: move || {
+                let this = this.root();
+
+                // TODO: Step 1. Set the select element's user validity to true.
+
+                // Step 2. Fire an event named input at the select element, with the bubbles and composed
+                // attributes initialized to true.
+                this.upcast::<EventTarget>()
+                    .fire_event_with_params(
+                        atom!("input"),
+                        EventBubbles::Bubbles,
+                        EventCancelable::NotCancelable,
+                        EventComposed::Composed,
+                        CanGc::note(),
+                    );
+
+                // Step 3. Fire an event named change at the select element, with the bubbles attribute initialized
+                // to true.
+                this.upcast::<EventTarget>()
+                    .fire_bubbling_event(atom!("change"), CanGc::note());
+            }));
+    }
+}
+
+impl HTMLSelectElementMethods<crate::DomTypeHolder> for HTMLSelectElement {
+    /// <https://html.spec.whatwg.org/multipage/#dom-select-add>
+    fn Add(
+        &self,
+        element: HTMLOptionElementOrHTMLOptGroupElement,
+        before: Option<HTMLElementOrLong>,
+    ) -> ErrorResult {
+        self.Options().Add(element, before)
+    }
+
+    // https://html.spec.whatwg.org/multipage/#dom-fe-disabled
+    make_bool_getter!(Disabled, "disabled");
+
+    // https://html.spec.whatwg.org/multipage/#dom-fe-disabled
+    make_bool_setter!(SetDisabled, "disabled");
+
+    /// <https://html.spec.whatwg.org/multipage/#dom-fae-form>
+    fn GetForm(&self) -> Option<DomRoot<HTMLFormElement>> {
+        self.form_owner()
+    }
+
+    // https://html.spec.whatwg.org/multipage/#dom-select-multiple
+    make_bool_getter!(Multiple, "multiple");
+
+    // https://html.spec.whatwg.org/multipage/#dom-select-multiple
+    make_bool_setter!(SetMultiple, "multiple");
+
+    // https://html.spec.whatwg.org/multipage/#dom-fe-name
+    make_getter!(Name, "name");
+
+    // https://html.spec.whatwg.org/multipage/#dom-fe-name
+    make_atomic_setter!(SetName, "name");
+
+    // https://html.spec.whatwg.org/multipage/#dom-select-required
+    make_bool_getter!(Required, "required");
+
+    // https://html.spec.whatwg.org/multipage/#dom-select-required
+    make_bool_setter!(SetRequired, "required");
+
+    // https://html.spec.whatwg.org/multipage/#dom-select-size
+    make_uint_getter!(Size, "size", DEFAULT_SELECT_SIZE);
+
+    // https://html.spec.whatwg.org/multipage/#dom-select-size
+    make_uint_setter!(SetSize, "size", DEFAULT_SELECT_SIZE);
+
+    /// <https://html.spec.whatwg.org/multipage/#dom-select-type>
+    fn Type(&self) -> DOMString {
+        DOMString::from(if self.Multiple() {
+            "select-multiple"
+        } else {
+            "select-one"
+        })
+    }
+
+    // https://html.spec.whatwg.org/multipage/#dom-lfe-labels
+    make_labels_getter!(Labels, labels_node_list);
+
+    /// <https://html.spec.whatwg.org/multipage/#dom-select-options>
+    fn Options(&self) -> DomRoot<HTMLOptionsCollection> {
+        self.options.or_init(|| {
+            let window = self.owner_window();
+            HTMLOptionsCollection::new(&window, self, Box::new(OptionsFilter), CanGc::note())
+        })
+    }
+
+    /// <https://html.spec.whatwg.org/multipage/#dom-select-length>
+    fn Length(&self) -> u32 {
+        self.Options().Length()
+    }
+
+    /// <https://html.spec.whatwg.org/multipage/#dom-select-length>
+    fn SetLength(&self, length: u32, can_gc: CanGc) {
+        self.Options().SetLength(length, can_gc)
+    }
+
+    /// <https://html.spec.whatwg.org/multipage/#dom-select-item>
+    fn Item(&self, index: u32) -> Option<DomRoot<Element>> {
+        self.Options().upcast().Item(index)
+    }
+
+    /// <https://html.spec.whatwg.org/multipage/#dom-select-item>
+    fn IndexedGetter(&self, index: u32) -> Option<DomRoot<Element>> {
+        self.Options().IndexedGetter(index)
+    }
+
+    /// <https://html.spec.whatwg.org/multipage/#dom-select-setter>
+    fn IndexedSetter(
+        &self,
+        index: u32,
+        value: Option<&HTMLOptionElement>,
+        can_gc: CanGc,
+    ) -> ErrorResult {
+        self.Options().IndexedSetter(index, value, can_gc)
+    }
+
+    /// <https://html.spec.whatwg.org/multipage/#dom-select-nameditem>
+    fn NamedItem(&self, name: DOMString) -> Option<DomRoot<HTMLOptionElement>> {
+        self.Options()
+            .NamedGetter(name)
+            .and_then(DomRoot::downcast::<HTMLOptionElement>)
+    }
+
+    /// <https://html.spec.whatwg.org/multipage/#dom-select-remove>
+    fn Remove_(&self, index: i32) {
+        self.Options().Remove(index)
+    }
+
+    /// <https://html.spec.whatwg.org/multipage/#dom-select-remove>
+    fn Remove(&self) {
+        self.upcast::<Element>().Remove(CanGc::note())
+    }
+
+    /// <https://html.spec.whatwg.org/multipage/#dom-select-value>
+    fn Value(&self) -> DOMString {
+        self.list_of_options()
+            .find(|opt_elem| opt_elem.Selected())
+            .map(|opt_elem| opt_elem.Value())
+            .unwrap_or_default()
+    }
+
+    /// <https://html.spec.whatwg.org/multipage/#dom-select-value>
+    fn SetValue(&self, value: DOMString) {
+        let mut opt_iter = self.list_of_options();
+        // Reset until we find an <option> with a matching value
+        for opt in opt_iter.by_ref() {
+            if opt.Value() == value {
+                opt.set_selectedness(true);
+                opt.set_dirtiness(true);
+                break;
+            }
+            opt.set_selectedness(false);
+        }
+        // Reset remaining <option> elements
+        for opt in opt_iter {
+            opt.set_selectedness(false);
+        }
+
+        self.validity_state()
+            .perform_validation_and_update(ValidationFlags::VALUE_MISSING, CanGc::note());
+    }
+
+    /// <https://html.spec.whatwg.org/multipage/#dom-select-selectedindex>
+    fn SelectedIndex(&self) -> i32 {
+        self.list_of_options()
+            .enumerate()
+            .filter(|(_, opt_elem)| opt_elem.Selected())
+            .map(|(i, _)| i as i32)
+            .next()
+            .unwrap_or(-1)
+    }
+
+    /// <https://html.spec.whatwg.org/multipage/#dom-select-selectedindex>
+    fn SetSelectedIndex(&self, index: i32, can_gc: CanGc) {
+        let mut selection_did_change = false;
+
+        let mut opt_iter = self.list_of_options();
+        for opt in opt_iter.by_ref().take(index as usize) {
+            selection_did_change |= opt.Selected();
+            opt.set_selectedness(false);
+        }
+        if let Some(selected_option) = opt_iter.next() {
+            selection_did_change |= !selected_option.Selected();
+            selected_option.set_selectedness(true);
+            selected_option.set_dirtiness(true);
+
+            // Reset remaining <option> elements
+            for opt in opt_iter {
+                selection_did_change |= opt.Selected();
+                opt.set_selectedness(false);
+            }
+        }
+
+        if selection_did_change {
+            self.update_shadow_tree(can_gc);
+        }
+    }
+
+    /// <https://html.spec.whatwg.org/multipage/#dom-cva-willvalidate>
+    fn WillValidate(&self) -> bool {
+        self.is_instance_validatable()
+    }
+
+    /// <https://html.spec.whatwg.org/multipage/#dom-cva-validity>
+    fn Validity(&self) -> DomRoot<ValidityState> {
+        self.validity_state()
+    }
+
+    /// <https://html.spec.whatwg.org/multipage/#dom-cva-checkvalidity>
+    fn CheckValidity(&self, can_gc: CanGc) -> bool {
+        self.check_validity(can_gc)
+    }
+
+    /// <https://html.spec.whatwg.org/multipage/#dom-cva-reportvalidity>
+    fn ReportValidity(&self, can_gc: CanGc) -> bool {
+        self.report_validity(can_gc)
+    }
+
+    /// <https://html.spec.whatwg.org/multipage/#dom-cva-validationmessage>
+    fn ValidationMessage(&self) -> DOMString {
+        self.validation_message()
+    }
+
+    /// <https://html.spec.whatwg.org/multipage/#dom-cva-setcustomvalidity>
+    fn SetCustomValidity(&self, error: DOMString) {
+        self.validity_state().set_custom_error_message(error);
+    }
+}
+
+impl VirtualMethods for HTMLSelectElement {
+    fn super_type(&self) -> Option<&dyn VirtualMethods> {
+        Some(self.upcast::<HTMLElement>() as &dyn VirtualMethods)
+    }
+
+    fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation, can_gc: CanGc) {
+        self.super_type()
+            .unwrap()
+            .attribute_mutated(attr, mutation, can_gc);
+        match *attr.local_name() {
+            local_name!("required") => {
+                self.validity_state()
+                    .perform_validation_and_update(ValidationFlags::VALUE_MISSING, can_gc);
+            },
+            local_name!("disabled") => {
+                let el = self.upcast::<Element>();
+                match mutation {
+                    AttributeMutation::Set(_) => {
+                        el.set_disabled_state(true);
+                        el.set_enabled_state(false);
+                    },
+                    AttributeMutation::Removed => {
+                        el.set_disabled_state(false);
+                        el.set_enabled_state(true);
+                        el.check_ancestors_disabled_state_for_form_control();
+                    },
+                }
+
+                self.validity_state()
+                    .perform_validation_and_update(ValidationFlags::VALUE_MISSING, can_gc);
+            },
+            local_name!("form") => {
+                self.form_attribute_mutated(mutation, can_gc);
+            },
+            _ => {},
+        }
+    }
+
+    fn bind_to_tree(&self, context: &BindContext, can_gc: CanGc) {
+        if let Some(s) = self.super_type() {
+            s.bind_to_tree(context, can_gc);
+        }
+
+        self.upcast::<Element>()
+            .check_ancestors_disabled_state_for_form_control();
+    }
+
+    fn unbind_from_tree(&self, context: &UnbindContext, can_gc: CanGc) {
+        self.super_type().unwrap().unbind_from_tree(context, can_gc);
+
+        let node = self.upcast::<Node>();
+        let el = self.upcast::<Element>();
+        if node
+            .ancestors()
+            .any(|ancestor| ancestor.is::<HTMLFieldSetElement>())
+        {
+            el.check_ancestors_disabled_state_for_form_control();
+        } else {
+            el.check_disabled_attribute();
+        }
+    }
+
+    fn children_changed(&self, mutation: &ChildrenMutation) {
+        if let Some(s) = self.super_type() {
+            s.children_changed(mutation);
+        }
+
+        self.update_shadow_tree(CanGc::note());
+    }
+
+    fn parse_plain_attribute(&self, local_name: &LocalName, value: DOMString) -> AttrValue {
+        match *local_name {
+            local_name!("size") => AttrValue::from_u32(value.into(), DEFAULT_SELECT_SIZE),
+            _ => self
+                .super_type()
+                .unwrap()
+                .parse_plain_attribute(local_name, value),
+        }
+    }
+}
+
+impl FormControl for HTMLSelectElement {
+    fn form_owner(&self) -> Option<DomRoot<HTMLFormElement>> {
+        self.form_owner.get()
+    }
+
+    fn set_form_owner(&self, form: Option<&HTMLFormElement>) {
+        self.form_owner.set(form);
+    }
+
+    fn to_element(&self) -> &Element {
+        self.upcast::<Element>()
+    }
+}
+
+impl Validatable for HTMLSelectElement {
+    fn as_element(&self) -> &Element {
+        self.upcast()
+    }
+
+    fn validity_state(&self) -> DomRoot<ValidityState> {
+        self.validity_state
+            .or_init(|| ValidityState::new(&self.owner_window(), self.upcast(), CanGc::note()))
+    }
+
+    fn is_instance_validatable(&self) -> bool {
+        // https://html.spec.whatwg.org/multipage/#enabling-and-disabling-form-controls%3A-the-disabled-attribute%3Abarred-from-constraint-validation
+        // https://html.spec.whatwg.org/multipage/#the-datalist-element%3Abarred-from-constraint-validation
+        !self.upcast::<Element>().disabled_state() && !is_barred_by_datalist_ancestor(self.upcast())
+    }
+
+    fn perform_validation(
+        &self,
+        validate_flags: ValidationFlags,
+        _can_gc: CanGc,
+    ) -> ValidationFlags {
+        let mut failed_flags = ValidationFlags::empty();
+
+        // https://html.spec.whatwg.org/multipage/#suffering-from-being-missing
+        // https://html.spec.whatwg.org/multipage/#the-select-element%3Asuffering-from-being-missing
+        if validate_flags.contains(ValidationFlags::VALUE_MISSING) && self.Required() {
+            let placeholder = self.get_placeholder_label_option();
+            let is_value_missing = !self
+                .list_of_options()
+                .any(|e| e.Selected() && placeholder != Some(e));
+            failed_flags.set(ValidationFlags::VALUE_MISSING, is_value_missing);
+        }
+
+        failed_flags
+    }
+}
+
+impl Activatable for HTMLSelectElement {
+    fn as_element(&self) -> &Element {
+        self.upcast()
+    }
+
+    fn is_instance_activatable(&self) -> bool {
+        true
+    }
+
+    fn activation_behavior(&self, _event: &Event, _target: &EventTarget, can_gc: CanGc) {
+        let Some(selected_value) = self.show_menu() else {
+            // The user did not select a value
+            return;
+        };
+
+        self.SetSelectedIndex(selected_value as i32, can_gc);
+        self.send_update_notifications();
+    }
+}
+
+enum Choice3<I, J, K> {
+    First(I),
+    Second(J),
+    Third(K),
+}
+
+impl<I, J, K, T> Iterator for Choice3<I, J, K>
+where
+    I: Iterator<Item = T>,
+    J: Iterator<Item = T>,
+    K: Iterator<Item = T>,
+{
+    type Item = T;
+
+    fn next(&mut self) -> Option<T> {
+        match *self {
+            Choice3::First(ref mut i) => i.next(),
+            Choice3::Second(ref mut j) => j.next(),
+            Choice3::Third(ref mut k) => k.next(),
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        match *self {
+            Choice3::First(ref i) => i.size_hint(),
+            Choice3::Second(ref j) => j.size_hint(),
+            Choice3::Third(ref k) => k.size_hint(),
+        }
+    }
+}