script/dom/html/form_controls/

htmltextareaelement.rs

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */

use std::cell::{Cell, Ref, RefCell, RefMut};
use std::default::Default;

use dom_struct::dom_struct;
use embedder_traits::{EmbedderControlRequest, InputMethodRequest, InputMethodType};
use html5ever::{LocalName, Prefix, local_name, ns};
use js::context::{JSContext, NoGC};
use js::rust::HandleObject;
use script_bindings::cell::DomRefCell;
use script_bindings::codegen::GenericBindings::SelectionBinding::SelectionMethods;
use script_bindings::domstring::TracedDOMString;
use servo_base::text::{RangeAny, Utf16CodeUnits, Utf32CodeUnits};
use style::attr::AttrValue;
use stylo_dom::ElementState;

use crate::dom::bindings::codegen::Bindings::HTMLFormElementBinding::SelectionMode;
use crate::dom::bindings::codegen::Bindings::HTMLTextAreaElementBinding::HTMLTextAreaElementMethods;
use crate::dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
use crate::dom::bindings::error::ErrorResult;
use crate::dom::bindings::inheritance::Castable;
use crate::dom::bindings::refcounted::Trusted;
use crate::dom::bindings::root::{Dom, DomRoot, LayoutDom, MutNullableDom};
use crate::dom::bindings::str::DOMString;
use crate::dom::document::Document;
use crate::dom::document_embedder_controls::ControlElement;
use crate::dom::element::attributes::storage::AttrRef;
use crate::dom::element::{AttributeMutation, Element};
use crate::dom::event::Event;
use crate::dom::event::event::{EventBubbles, EventCancelable, EventComposed};
use crate::dom::eventtarget::EventTarget;
use crate::dom::html::form_controls::htmlinputelement::HTMLInputElement;
use crate::dom::html::form_controls::input_type::text_input_widget::TextInputWidget;
use crate::dom::html::form_controls::text_control::TextControlElement;
use crate::dom::html::form_controls::text_input::{KeyReaction, Lines, TextInput};
use crate::dom::html::htmlelement::HTMLElement;
use crate::dom::html::htmlformelement::{FormControl, HTMLFormElement};
use crate::dom::node::virtualmethods::VirtualMethods;
use crate::dom::node::{
    BindContext, ChildrenMutation, CloneChildrenFlag, Node, NodeTraits, UnbindContext,
};
use crate::dom::nodelist::NodeList;
use crate::dom::text_input::EmbedderClipboardProvider;
use crate::dom::types::FocusEvent;
use crate::dom::validation::{Validatable, is_barred_by_datalist_ancestor};
use crate::dom::validitystate::{ValidationFlags, ValidityState};

#[dom_struct]
pub(crate) struct HTMLTextAreaElement {
    htmlelement: HTMLElement,
    #[no_trace]
    text_input: DomRefCell<TextInput<EmbedderClipboardProvider>>,
    placeholder: RefCell<TracedDOMString>,
    // https://html.spec.whatwg.org/multipage/#concept-textarea-dirty
    value_dirty: Cell<bool>,
    form_owner: MutNullableDom<HTMLFormElement>,
    labels_node_list: MutNullableDom<NodeList>,
    validity_state: MutNullableDom<ValidityState>,
    /// A [`TextInputWidget`] that manages the shadow DOM for this `<textarea>`.
    text_input_widget: DomRefCell<TextInputWidget>,

    /// <https://w3c.github.io/selection-api/#dfn-has-scheduled-selectionchange-event>
    has_scheduled_selectionchange_event: Cell<bool>,
}

impl LayoutDom<'_, HTMLTextAreaElement> {
    pub(crate) fn selection_for_layout(self) -> Option<RangeAny<Utf32CodeUnits>> {
        let element = self.unsafe_get();
        #[expect(unsafe_code)]
        let text_input = unsafe { element.text_input.borrow_for_layout() };
        text_input.selection_for_layout
    }

    pub(crate) fn get_cols(self) -> u32 {
        self.upcast::<Element>()
            .get_attr_for_layout(&ns!(), &local_name!("cols"))
            .map_or(DEFAULT_COLS, AttrValue::as_uint)
    }

    pub(crate) fn get_rows(self) -> u32 {
        self.upcast::<Element>()
            .get_attr_for_layout(&ns!(), &local_name!("rows"))
            .map_or(DEFAULT_ROWS, AttrValue::as_uint)
    }
}

// https://html.spec.whatwg.org/multipage/#attr-textarea-cols-value
const DEFAULT_COLS: u32 = 20;

// https://html.spec.whatwg.org/multipage/#attr-textarea-rows-value
const DEFAULT_ROWS: u32 = 2;

const DEFAULT_MAX_LENGTH: i32 = -1;
const DEFAULT_MIN_LENGTH: i32 = -1;

impl HTMLTextAreaElement {
    fn new_inherited(
        local_name: LocalName,
        prefix: Option<Prefix>,
        document: &Document,
    ) -> HTMLTextAreaElement {
        let embedder_sender = document
            .window()
            .as_global_scope()
            .script_to_embedder_chan()
            .clone();
        HTMLTextAreaElement {
            htmlelement: HTMLElement::new_inherited_with_state(
                ElementState::ENABLED | ElementState::READWRITE,
                local_name,
                prefix,
                document,
            ),
            placeholder: Default::default(),
            text_input: DomRefCell::new(TextInput::new(
                Lines::Multiple,
                DOMString::new(),
                EmbedderClipboardProvider {
                    embedder_sender,
                    webview_id: document.webview_id(),
                },
            )),
            value_dirty: Cell::new(false),
            form_owner: Default::default(),
            labels_node_list: Default::default(),
            validity_state: Default::default(),
            text_input_widget: Default::default(),
            has_scheduled_selectionchange_event: Default::default(),
        }
    }

    pub(crate) fn new(
        cx: &mut JSContext,
        local_name: LocalName,
        prefix: Option<Prefix>,
        document: &Document,
        proto: Option<HandleObject>,
    ) -> DomRoot<HTMLTextAreaElement> {
        Node::reflect_node_with_proto(
            cx,
            Box::new(HTMLTextAreaElement::new_inherited(
                local_name, prefix, document,
            )),
            document,
            proto,
        )
    }

    pub(crate) fn auto_directionality(&self) -> String {
        let value: String = String::from(self.Value());
        HTMLInputElement::directionality_from_value(&value)
    }

    /// <https://html.spec.whatwg.org/multipage/#concept-fe-mutable>
    pub(crate) fn is_mutable(&self) -> bool {
        // https://html.spec.whatwg.org/multipage/#the-textarea-element%3Aconcept-fe-mutable
        // https://html.spec.whatwg.org/multipage/#the-readonly-attribute:concept-fe-mutable
        !(self.upcast::<Element>().disabled_state() || self.ReadOnly())
    }

    fn handle_focus_event(&self, cx: &mut JSContext, event: &FocusEvent) {
        let event_type = event.upcast::<Event>().type_();
        let document = self.owner_document();
        if *event_type == *"blur" {
            document
                .embedder_controls()
                .hide_embedder_control(self.upcast());
        } else if *event_type == *"focus" {
            // If there is a Document selection collapse it. This isn't really specified
            // and there are quite a few open specification issues about the interaction
            // of input and Document selection:
            // See <https://github.com/w3c/selection-api/issues/83>.
            if let Some(selection) = document.selection() {
                let _ = selection.Collapse(cx, None, 0);
            }

            document.embedder_controls().show_embedder_control(
                cx,
                ControlElement::Ime(Dom::from_ref(self.upcast())),
                EmbedderControlRequest::InputMethod(InputMethodRequest {
                    input_method_type: InputMethodType::Text,
                    text: String::from(self.Value()),
                    insertion_point: self.GetSelectionEnd(),
                    multiline: false,
                    // We follow chromium's heuristic to show the virtual keyboard only if user had interacted before.
                    allow_virtual_keyboard: self.owner_window().has_sticky_activation(),
                }),
                None,
            );
        }

        // Focus changes can activate or deactivate a selection.
        self.maybe_update_shared_selection();
    }

    /// <https://w3c.github.io/selection-api/#dfn-schedule-a-selectionchange-event>
    fn schedule_a_selection_change_event(&self) {
        // Step 1. If target's has scheduled selectionchange event is true, abort these steps.
        if self.has_scheduled_selectionchange_event.get() {
            return;
        }
        // Step 2. Set target's has scheduled selectionchange event to true.
        self.has_scheduled_selectionchange_event.set(true);
        // Step 3. Queue a task on the user interaction task source to fire a selectionchange event on target.
        let this = Trusted::new(self);
        self.owner_global()
            .task_manager()
            .user_interaction_task_source()
            .queue(
                // https://w3c.github.io/selection-api/#firing-selectionchange-event
                task!(selectionchange_task_steps: move |cx| {
                    let this = this.root();
                    // Step 1. Set target's has scheduled selectionchange event to false.
                    this.has_scheduled_selectionchange_event.set(false);
                    // Step 2. If target is an element, fire an event named selectionchange, which bubbles and not cancelable, at target.
                    this.upcast::<EventTarget>().fire_event_with_params(
                        cx,
                        atom!("selectionchange"),
                        EventBubbles::Bubbles,
                        EventCancelable::NotCancelable,
                        EventComposed::Composed,
                    );
                    // Step 3. Otherwise, if target is a document, fire an event named selectionchange,
                    // which does not bubble and not cancelable, at target.
                    //
                    // n/a
                }),
            );
    }
}

impl TextControlElement for HTMLTextAreaElement {
    fn as_element(&self) -> &Element {
        self.upcast()
    }

    fn text_input(&self) -> Ref<'_, TextInput<EmbedderClipboardProvider>> {
        self.text_input.borrow()
    }

    fn text_input_mut(&self) -> RefMut<'_, TextInput<EmbedderClipboardProvider>> {
        self.text_input.borrow_mut()
    }

    fn selection_api_applies(&self) -> bool {
        true
    }

    fn has_selectable_text(&self) -> bool {
        !self.text_input.borrow().get_content().is_empty()
    }

    fn has_uncollapsed_selection(&self) -> bool {
        self.text_input.borrow().has_uncollapsed_selection()
    }

    fn set_dirty_value_flag(&self, value: bool) {
        self.value_dirty.set(value)
    }

    fn select_all(&self) {
        self.text_input.borrow_mut().select_all();
        self.maybe_update_shared_selection();
    }

    fn maybe_update_shared_selection(&self) {
        let selection = {
            let mut text_input = self.text_input.borrow_mut();
            let selection_range = text_input.selection_start()..text_input.selection_end();
            let enabled = self.upcast::<Element>().focus_state();

            let range_remained_equal = selection_range == text_input.previous_selection_range;
            if range_remained_equal && enabled == text_input.selection_for_layout.is_some() {
                return;
            }

            if !range_remained_equal {
                // https://w3c.github.io/selection-api/#selectionchange-event
                // > When an input or textarea element provide a text selection and its selection changes
                // > (in either extent or direction),
                // > the user agent must schedule a selectionchange event on the element.
                self.schedule_a_selection_change_event();
            }

            let selection = enabled.then(|| text_input.sorted_selection_character_offsets_range());
            text_input.previous_selection_range = selection_range;
            text_input.selection_for_layout = selection;
            selection
        };

        if self
            .text_input_widget
            .borrow()
            .set_text_run_selection(selection)
        {
            // Found an already laid out text run to update, so we only need to repaint:
            self.owner_window().layout().set_needs_new_display_list();
        } else {
            // If there isn’t a text run, layout is pending to create it anyway
        }
    }

    fn placeholder_text<'a>(&'a self) -> Ref<'a, TracedDOMString> {
        self.placeholder.borrow()
    }

    fn value_text(&self) -> DOMString {
        self.Value()
    }

    fn read_only_or_disabled(&self) -> bool {
        self.ReadOnly() || self.Disabled()
    }

    fn handle_text_content_changed(&self, cx: &mut JSContext) {
        self.validity_state(cx)
            .perform_validation_and_update(cx, ValidationFlags::all());

        let placeholder_shown =
            self.text_input.borrow().is_empty() && !self.placeholder.borrow().is_empty();
        self.upcast::<Element>()
            .set_placeholder_shown_state(cx.no_gc(), placeholder_shown);

        self.text_input_widget.borrow().update_shadow_tree(cx, self);
        self.text_input_widget
            .borrow()
            .update_placeholder_contents(cx, self);
        self.maybe_update_shared_selection();
    }

    fn handle_key_reaction(&self, cx: &mut JSContext, action: KeyReaction) {
        match action {
            KeyReaction::TriggerDefaultAction => (),
            KeyReaction::DispatchInput(text, input_type) => {
                self.queue_input_event(text, input_type);
                self.value_dirty.set(true);
                self.handle_text_content_changed(cx);
                self.maybe_update_shared_selection();
            },
            KeyReaction::RedrawSelection => {
                self.maybe_update_shared_selection();
            },
            KeyReaction::Nothing => (),
        }
    }
}

impl HTMLTextAreaElementMethods<crate::DomTypeHolder> for HTMLTextAreaElement {
    // TODO A few of these attributes have default values and additional
    // constraints

    // https://html.spec.whatwg.org/multipage/#dom-textarea-cols
    make_uint_getter!(Cols, "cols", DEFAULT_COLS);

    // https://html.spec.whatwg.org/multipage/#dom-textarea-cols
    make_limited_uint_setter!(SetCols, "cols", DEFAULT_COLS);

    // https://html.spec.whatwg.org/multipage/#dom-input-dirName
    make_getter!(DirName, "dirname");

    // https://html.spec.whatwg.org/multipage/#dom-input-dirName
    make_setter!(SetDirName, "dirname");

    // 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/#attr-fe-name
    make_getter!(Name, "name");

    // https://html.spec.whatwg.org/multipage/#attr-fe-name
    make_atomic_setter!(SetName, "name");

    // https://html.spec.whatwg.org/multipage/#dom-textarea-placeholder
    make_getter!(Placeholder, "placeholder");

    // https://html.spec.whatwg.org/multipage/#dom-textarea-placeholder
    make_setter!(SetPlaceholder, "placeholder");

    // https://html.spec.whatwg.org/multipage/#attr-textarea-maxlength
    make_int_getter!(MaxLength, "maxlength", DEFAULT_MAX_LENGTH);

    // https://html.spec.whatwg.org/multipage/#attr-textarea-maxlength
    make_limited_int_setter!(SetMaxLength, "maxlength", DEFAULT_MAX_LENGTH);

    // https://html.spec.whatwg.org/multipage/#attr-textarea-minlength
    make_int_getter!(MinLength, "minlength", DEFAULT_MIN_LENGTH);

    // https://html.spec.whatwg.org/multipage/#attr-textarea-minlength
    make_limited_int_setter!(SetMinLength, "minlength", DEFAULT_MIN_LENGTH);

    // https://html.spec.whatwg.org/multipage/#attr-textarea-readonly
    make_bool_getter!(ReadOnly, "readonly");

    // https://html.spec.whatwg.org/multipage/#attr-textarea-readonly
    make_bool_setter!(SetReadOnly, "readonly");

    // https://html.spec.whatwg.org/multipage/#dom-textarea-required
    make_bool_getter!(Required, "required");

    // https://html.spec.whatwg.org/multipage/#dom-textarea-required
    make_bool_setter!(SetRequired, "required");

    // https://html.spec.whatwg.org/multipage/#dom-textarea-rows
    make_uint_getter!(Rows, "rows", DEFAULT_ROWS);

    // https://html.spec.whatwg.org/multipage/#dom-textarea-rows
    make_limited_uint_setter!(SetRows, "rows", DEFAULT_ROWS);

    // https://html.spec.whatwg.org/multipage/#dom-textarea-wrap
    make_getter!(Wrap, "wrap");

    // https://html.spec.whatwg.org/multipage/#dom-textarea-wrap
    make_setter!(SetWrap, "wrap");

    /// <https://html.spec.whatwg.org/multipage/#dom-textarea-type>
    fn Type(&self) -> DOMString {
        DOMString::from_static("textarea")
    }

    /// <https://html.spec.whatwg.org/multipage/#dom-textarea-defaultvalue>
    fn DefaultValue(&self) -> DOMString {
        self.upcast::<Node>().GetTextContent().unwrap()
    }

    /// <https://html.spec.whatwg.org/multipage/#dom-textarea-defaultvalue>
    fn SetDefaultValue(&self, cx: &mut JSContext, value: DOMString) {
        self.upcast::<Node>()
            .set_text_content_for_element(cx, Some(value));

        // if the element's dirty value flag is false, then the element's
        // raw value must be set to the value of the element's textContent IDL attribute
        if !self.value_dirty.get() {
            self.reset(cx);
        }
    }

    /// <https://html.spec.whatwg.org/multipage/#dom-textarea-value>
    fn Value(&self) -> DOMString {
        self.text_input.borrow().get_content()
    }

    /// <https://html.spec.whatwg.org/multipage/#dom-textarea-value>
    fn SetValue(&self, cx: &mut JSContext, value: DOMString) {
        // Step 1: Let oldAPIValue be this element's API value.
        let old_api_value = self.Value();

        // Step 2:  Set this element's raw value to the new value.
        self.text_input
            .safe_borrow_mut(cx.no_gc())
            .set_content(value);

        // Step 3: Set this element's dirty value flag to true.
        self.value_dirty.set(true);

        // Step 4: If the new API value is different from oldAPIValue, then move
        // the text entry cursor position to the end of the text control,
        // unselecting any selected text and resetting the selection direction to
        // "none".
        if old_api_value != self.Value() {
            self.text_input
                .safe_borrow_mut(cx.no_gc())
                .clear_selection_to_end();
            self.handle_text_content_changed(cx);
        }
    }

    /// <https://html.spec.whatwg.org/multipage/#dom-textarea-textlength>
    fn TextLength(&self) -> u32 {
        self.text_input.borrow().len_utf16().0
    }

    // https://html.spec.whatwg.org/multipage/#dom-lfe-labels
    make_labels_getter!(Labels, labels_node_list);

    /// <https://html.spec.whatwg.org/multipage/#dom-textarea/input-select>
    fn Select(&self, cx: &mut JSContext) {
        self.dom_select(cx);
    }

    /// <https://html.spec.whatwg.org/multipage/#dom-textarea/input-selectionstart>
    fn GetSelectionStart(&self) -> Option<u32> {
        self.dom_start().map(|start| start.0)
    }

    /// <https://html.spec.whatwg.org/multipage/#dom-textarea/input-selectionstart>
    fn SetSelectionStart(&self, _cx: &mut JSContext, start: Option<u32>) -> ErrorResult {
        self.set_dom_start(start.map(Utf16CodeUnits::from))
    }

    /// <https://html.spec.whatwg.org/multipage/#dom-textarea/input-selectionend>
    fn GetSelectionEnd(&self) -> Option<u32> {
        self.dom_end().map(|end| end.0)
    }

    /// <https://html.spec.whatwg.org/multipage/#dom-textarea/input-selectionend>
    fn SetSelectionEnd(&self, _cx: &mut JSContext, end: Option<u32>) -> ErrorResult {
        self.set_dom_end(end.map(Utf16CodeUnits::from))
    }

    /// <https://html.spec.whatwg.org/multipage/#dom-textarea/input-selectiondirection>
    fn GetSelectionDirection(&self) -> Option<DOMString> {
        self.dom_direction()
    }

    /// <https://html.spec.whatwg.org/multipage/#dom-textarea/input-selectiondirection>
    fn SetSelectionDirection(
        &self,
        _cx: &mut JSContext,
        direction: Option<DOMString>,
    ) -> ErrorResult {
        self.set_dom_direction(direction)
    }

    /// <https://html.spec.whatwg.org/multipage/#dom-textarea/input-setselectionrange>
    fn SetSelectionRange(&self, start: u32, end: u32, direction: Option<DOMString>) -> ErrorResult {
        self.set_dom_range(
            Utf16CodeUnits::from(start),
            Utf16CodeUnits::from(end),
            direction,
        )
    }

    /// <https://html.spec.whatwg.org/multipage/#dom-textarea/input-setrangetext>
    fn SetRangeText(&self, cx: &mut JSContext, replacement: DOMString) -> ErrorResult {
        self.set_dom_range_text(cx, replacement, None, None, Default::default())
    }

    /// <https://html.spec.whatwg.org/multipage/#dom-textarea/input-setrangetext>
    fn SetRangeText_(
        &self,
        cx: &mut JSContext,
        replacement: DOMString,
        start: u32,
        end: u32,
        selection_mode: SelectionMode,
    ) -> ErrorResult {
        self.set_dom_range_text(
            cx,
            replacement,
            Some(Utf16CodeUnits::from(start)),
            Some(Utf16CodeUnits::from(end)),
            selection_mode,
        )
    }

    /// <https://html.spec.whatwg.org/multipage/#dom-cva-willvalidate>
    fn WillValidate(&self, no_gc: &NoGC) -> bool {
        self.is_instance_validatable(no_gc)
    }

    /// <https://html.spec.whatwg.org/multipage/#dom-cva-validity>
    fn Validity(&self, cx: &mut JSContext) -> DomRoot<ValidityState> {
        self.validity_state(cx)
    }

    /// <https://html.spec.whatwg.org/multipage/#dom-cva-checkvalidity>
    fn CheckValidity(&self, cx: &mut JSContext) -> bool {
        self.check_validity(cx)
    }

    /// <https://html.spec.whatwg.org/multipage/#dom-cva-reportvalidity>
    fn ReportValidity(&self, cx: &mut JSContext) -> bool {
        self.report_validity(cx)
    }

    /// <https://html.spec.whatwg.org/multipage/#dom-cva-validationmessage>
    fn ValidationMessage(&self, cx: &mut JSContext) -> DOMString {
        self.validation_message(cx)
    }

    /// <https://html.spec.whatwg.org/multipage/#dom-cva-setcustomvalidity>
    fn SetCustomValidity(&self, cx: &mut JSContext, error: DOMString) {
        self.validity_state(cx).set_custom_error_message(cx, error);
    }
}

impl HTMLTextAreaElement {
    /// <https://w3c.github.io/webdriver/#ref-for-dfn-clear-algorithm-4>
    /// Used by WebDriver to clear the textarea element.
    pub(crate) fn clear(&self) {
        self.value_dirty.set(false);
        self.text_input.borrow_mut().set_content(DOMString::new());
    }

    pub(crate) fn reset(&self, cx: &mut JSContext) {
        // https://html.spec.whatwg.org/multipage/#the-textarea-element:concept-form-reset-control
        self.value_dirty.set(false);
        self.text_input
            .safe_borrow_mut(cx.no_gc())
            .set_content(self.DefaultValue());
        self.handle_text_content_changed(cx);
    }
}

impl VirtualMethods for HTMLTextAreaElement {
    fn super_type(&self) -> Option<&dyn VirtualMethods> {
        Some(self.upcast::<HTMLElement>() as &dyn VirtualMethods)
    }

    fn attribute_mutated(
        &self,
        cx: &mut JSContext,
        attr: AttrRef<'_>,
        mutation: AttributeMutation,
    ) {
        self.super_type()
            .unwrap()
            .attribute_mutated(cx, attr, mutation);
        match *attr.local_name() {
            local_name!("disabled") => {
                let el = self.upcast::<Element>();
                match mutation {
                    AttributeMutation::Set(_) => {
                        el.set_read_write_state(cx.no_gc(), false);
                    },
                    AttributeMutation::Removed => {
                        if !el.disabled_state() && !el.read_write_state() {
                            el.set_read_write_state(cx.no_gc(), true);
                        }
                    },
                }
            },
            local_name!("maxlength") => match *attr.value() {
                AttrValue::Int(_, value) => {
                    let mut text_input = self.text_input.safe_borrow_mut(cx.no_gc());

                    if value < 0 {
                        text_input.set_max_length(None);
                    } else {
                        text_input.set_max_length(Some(Utf16CodeUnits(value as u32)))
                    }
                },
                _ => panic!("Expected an AttrValue::Int"),
            },
            local_name!("minlength") => match *attr.value() {
                AttrValue::Int(_, value) => {
                    let mut text_input = self.text_input.safe_borrow_mut(cx.no_gc());

                    if value < 0 {
                        text_input.set_min_length(None);
                    } else {
                        text_input.set_min_length(Some(Utf16CodeUnits(value as u32)))
                    }
                },
                _ => panic!("Expected an AttrValue::Int"),
            },
            local_name!("placeholder") => {
                {
                    let mut placeholder = self.placeholder.borrow_mut();
                    match mutation {
                        AttributeMutation::Set(_) => {
                            let value = attr.value();
                            let value_str: &str = value.as_ref();
                            *placeholder =
                                value_str.replace("\r\n", "\n").replace('\r', "\n").into();
                        },
                        AttributeMutation::Removed => placeholder.clear(),
                    }
                }
                self.handle_text_content_changed(cx);
            },
            local_name!("readonly") => {
                let el = self.upcast::<Element>();
                match mutation {
                    AttributeMutation::Set(_) => {
                        el.set_read_write_state(cx.no_gc(), false);
                    },
                    AttributeMutation::Removed => {
                        el.set_read_write_state(cx.no_gc(), !el.disabled_state());
                    },
                }
            },
            local_name!("form") => {
                self.form_attribute_mutated(cx, mutation);
            },
            _ => {},
        }

        self.validity_state(cx)
            .perform_validation_and_update(cx, ValidationFlags::all());
    }

    fn bind_to_tree(&self, cx: &mut JSContext, context: &BindContext) {
        if let Some(s) = self.super_type() {
            s.bind_to_tree(cx, context);
        }
        self.handle_text_content_changed(cx);
    }

    fn parse_plain_attribute(&self, name: &LocalName, value: DOMString) -> AttrValue {
        match *name {
            local_name!("cols") => AttrValue::from_limited_u32(value.into(), DEFAULT_COLS),
            local_name!("rows") => AttrValue::from_limited_u32(value.into(), DEFAULT_ROWS),
            local_name!("maxlength") => {
                AttrValue::from_limited_i32(value.into(), DEFAULT_MAX_LENGTH)
            },
            local_name!("minlength") => {
                AttrValue::from_limited_i32(value.into(), DEFAULT_MIN_LENGTH)
            },
            _ => self
                .super_type()
                .unwrap()
                .parse_plain_attribute(name, value),
        }
    }

    fn unbind_from_tree(&self, cx: &mut JSContext, context: &UnbindContext) {
        // Always attempt to hide IME when unbinding input elements from the tree.
        self.owner_document()
            .embedder_controls()
            .hide_embedder_control(self.upcast());

        self.super_type().unwrap().unbind_from_tree(cx, context);
        self.validity_state(cx)
            .perform_validation_and_update(cx, ValidationFlags::all());
    }

    // The cloning steps for textarea elements must propagate the raw value
    // and dirty value flag from the node being cloned to the copy.
    fn cloning_steps(
        &self,
        cx: &mut JSContext,
        copy: &Node,
        maybe_doc: Option<&Document>,
        clone_children: CloneChildrenFlag,
    ) {
        if let Some(s) = self.super_type() {
            s.cloning_steps(cx, copy, maybe_doc, clone_children);
        }
        let el = copy.downcast::<HTMLTextAreaElement>().unwrap();
        el.value_dirty.set(self.value_dirty.get());
        {
            let mut text_input = el.text_input.safe_borrow_mut(cx.no_gc());
            text_input.set_content(self.text_input.borrow().get_content());
        }
        el.validity_state(cx)
            .perform_validation_and_update(cx, ValidationFlags::all());
    }

    fn children_changed(&self, cx: &mut JSContext, mutation: &ChildrenMutation) {
        if let Some(s) = self.super_type() {
            s.children_changed(cx, mutation);
        }
        if !self.value_dirty.get() {
            self.reset(cx);
        }
    }

    // copied and modified from htmlinputelement.rs
    fn handle_event(&self, cx: &mut JSContext, event: &Event) {
        if let Some(event) = event.downcast::<FocusEvent>() {
            self.handle_focus_event(cx, event);
        }

        self.validity_state(cx)
            .perform_validation_and_update(cx, ValidationFlags::all());

        if let Some(super_type) = self.super_type() {
            super_type.handle_event(cx, event);
        }
    }

    fn pop(&self, cx: &mut JSContext) {
        self.super_type().unwrap().pop(cx);

        // https://html.spec.whatwg.org/multipage/#the-textarea-element:stack-of-open-elements
        self.reset(cx);
    }
}

impl FormControl for HTMLTextAreaElement {
    fn form_owner(&self) -> Option<DomRoot<HTMLFormElement>> {
        self.form_owner.get()
    }

    fn set_form_owner(&self, _cx: &mut JSContext, form: Option<&HTMLFormElement>) {
        self.form_owner.set(form);
    }

    fn to_html_element(&self) -> &HTMLElement {
        self.upcast::<HTMLElement>()
    }
}

impl Validatable for HTMLTextAreaElement {
    fn as_element(&self) -> &Element {
        self.upcast()
    }

    fn validity_state(&self, cx: &mut JSContext) -> DomRoot<ValidityState> {
        self.validity_state
            .or_init(|| ValidityState::new(cx, &self.owner_window(), self.upcast()))
    }

    fn is_instance_validatable(&self, no_gc: &NoGC) -> 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-textarea-element%3Abarred-from-constraint-validation
        // https://html.spec.whatwg.org/multipage/#the-datalist-element%3Abarred-from-constraint-validation
        !self.upcast::<Element>().disabled_state() &&
            !self.ReadOnly() &&
            !is_barred_by_datalist_ancestor(no_gc, self.upcast())
    }

    fn perform_validation(
        &self,
        _cx: &mut JSContext,
        validate_flags: ValidationFlags,
    ) -> ValidationFlags {
        let mut failed_flags = ValidationFlags::empty();

        let text_input = self.text_input.borrow();
        let Utf16CodeUnits(value_len) = text_input.len_utf16();
        let last_edit_by_user = !text_input.was_last_change_by_set_content();
        let value_dirty = self.value_dirty.get();

        // https://html.spec.whatwg.org/multipage/#suffering-from-being-missing
        // https://html.spec.whatwg.org/multipage/#the-textarea-element%3Asuffering-from-being-missing
        if validate_flags.contains(ValidationFlags::VALUE_MISSING) &&
            self.Required() &&
            self.is_mutable() &&
            value_len == 0
        {
            failed_flags.insert(ValidationFlags::VALUE_MISSING);
        }

        if value_dirty && last_edit_by_user && value_len > 0 {
            // https://html.spec.whatwg.org/multipage/#suffering-from-being-too-long
            // https://html.spec.whatwg.org/multipage/#limiting-user-input-length%3A-the-maxlength-attribute%3Asuffering-from-being-too-long
            if validate_flags.contains(ValidationFlags::TOO_LONG) {
                let max_length = self.MaxLength();
                if max_length != DEFAULT_MAX_LENGTH && value_len > (max_length as u32) {
                    failed_flags.insert(ValidationFlags::TOO_LONG);
                }
            }

            // https://html.spec.whatwg.org/multipage/#suffering-from-being-too-short
            // https://html.spec.whatwg.org/multipage/#setting-minimum-input-length-requirements%3A-the-minlength-attribute%3Asuffering-from-being-too-short
            if validate_flags.contains(ValidationFlags::TOO_SHORT) {
                let min_length = self.MinLength();
                if min_length != DEFAULT_MIN_LENGTH && value_len < (min_length as u32) {
                    failed_flags.insert(ValidationFlags::TOO_SHORT);
                }
            }
        }

        failed_flags
    }
}