<input type="range"> changing to disabled while active breaks all pointer events
[WebKit-https.git] / Source / WebCore / html / shadow / SliderThumbElement.cpp
1 /*
2  * Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
3  * Copyright (C) 2010 Google Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are
7  * met:
8  *
9  *     * Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *     * Redistributions in binary form must reproduce the above
12  * copyright notice, this list of conditions and the following disclaimer
13  * in the documentation and/or other materials provided with the
14  * distribution.
15  *     * Neither the name of Google Inc. nor the names of its
16  * contributors may be used to endorse or promote products derived from
17  * this software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31
32
33 #include "config.h"
34 #include "SliderThumbElement.h"
35
36 #include "CSSValueKeywords.h"
37 #include "Event.h"
38 #include "EventHandler.h"
39 #include "EventNames.h"
40 #include "Frame.h"
41 #include "HTMLInputElement.h"
42 #include "HTMLParserIdioms.h"
43 #include "MouseEvent.h"
44 #include "RenderFlexibleBox.h"
45 #include "RenderSlider.h"
46 #include "RenderTheme.h"
47 #include "ShadowRoot.h"
48 #include "StyleResolver.h"
49
50 #if ENABLE(IOS_TOUCH_EVENTS)
51 #include "Document.h"
52 #include "Page.h"
53 #include "TouchEvent.h"
54 #endif
55
56 namespace WebCore {
57
58 using namespace HTMLNames;
59
60 inline static Decimal sliderPosition(HTMLInputElement& element)
61 {
62     const StepRange stepRange(element.createStepRange(RejectAny));
63     const Decimal oldValue = parseToDecimalForNumberType(element.value(), stepRange.defaultValue());
64     return stepRange.proportionFromValue(stepRange.clampValue(oldValue));
65 }
66
67 inline static bool hasVerticalAppearance(HTMLInputElement& input)
68 {
69     ASSERT(input.renderer());
70     const RenderStyle& sliderStyle = input.renderer()->style();
71
72 #if ENABLE(VIDEO)
73     if (sliderStyle.appearance() == MediaVolumeSliderPart && input.renderer()->theme().usesVerticalVolumeSlider())
74         return true;
75 #endif
76
77     return sliderStyle.appearance() == SliderVerticalPart;
78 }
79
80 // --------------------------------
81
82 RenderSliderThumb::RenderSliderThumb(SliderThumbElement& element, RenderStyle&& style)
83     : RenderBlockFlow(element, WTFMove(style))
84 {
85 }
86
87 void RenderSliderThumb::updateAppearance(const RenderStyle* parentStyle)
88 {
89     if (parentStyle->appearance() == SliderVerticalPart)
90         mutableStyle().setAppearance(SliderThumbVerticalPart);
91     else if (parentStyle->appearance() == SliderHorizontalPart)
92         mutableStyle().setAppearance(SliderThumbHorizontalPart);
93     else if (parentStyle->appearance() == MediaSliderPart)
94         mutableStyle().setAppearance(MediaSliderThumbPart);
95     else if (parentStyle->appearance() == MediaVolumeSliderPart)
96         mutableStyle().setAppearance(MediaVolumeSliderThumbPart);
97     else if (parentStyle->appearance() == MediaFullScreenVolumeSliderPart)
98         mutableStyle().setAppearance(MediaFullScreenVolumeSliderThumbPart);
99     if (style().hasAppearance()) {
100         ASSERT(element());
101         theme().adjustSliderThumbSize(mutableStyle(), element());
102     }
103 }
104
105 bool RenderSliderThumb::isSliderThumb() const
106 {
107     return true;
108 }
109
110 // --------------------------------
111
112 // FIXME: Find a way to cascade appearance and adjust heights, and get rid of this class.
113 // http://webkit.org/b/62535
114 class RenderSliderContainer final : public RenderFlexibleBox {
115 public:
116     RenderSliderContainer(SliderContainerElement& element, RenderStyle&& style)
117         : RenderFlexibleBox(element, WTFMove(style))
118     {
119     }
120
121 public:
122     RenderBox::LogicalExtentComputedValues computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit logicalTop) const override;
123
124 private:
125     void layout() override;
126     bool isFlexibleBoxImpl() const override { return true; }
127 };
128
129 RenderBox::LogicalExtentComputedValues RenderSliderContainer::computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit logicalTop) const
130 {
131     ASSERT(element()->shadowHost());
132     auto& input = downcast<HTMLInputElement>(*element()->shadowHost());
133     bool isVertical = hasVerticalAppearance(input);
134
135 #if ENABLE(DATALIST_ELEMENT)
136     if (input.renderer()->isSlider() && !isVertical && input.list()) {
137         int offsetFromCenter = theme().sliderTickOffsetFromTrackCenter();
138         LayoutUnit trackHeight = 0;
139         if (offsetFromCenter < 0)
140             trackHeight = -2 * offsetFromCenter;
141         else {
142             int tickLength = theme().sliderTickSize().height();
143             trackHeight = 2 * (offsetFromCenter + tickLength);
144         }
145         float zoomFactor = style().effectiveZoom();
146         if (zoomFactor != 1.0)
147             trackHeight *= zoomFactor;
148
149         return RenderBox::computeLogicalHeight(trackHeight, logicalTop);
150     }
151 #endif
152     if (isVertical)
153         logicalHeight = RenderSlider::defaultTrackLength;
154     return RenderBox::computeLogicalHeight(logicalHeight, logicalTop);
155 }
156
157 void RenderSliderContainer::layout()
158 {
159     ASSERT(element()->shadowHost());
160     auto& input = downcast<HTMLInputElement>(*element()->shadowHost());
161     bool isVertical = hasVerticalAppearance(input);
162     mutableStyle().setFlexDirection(isVertical ? FlowColumn : FlowRow);
163     TextDirection oldTextDirection = style().direction();
164     if (isVertical) {
165         // FIXME: Work around rounding issues in RTL vertical sliders. We want them to
166         // render identically to LTR vertical sliders. We can remove this work around when
167         // subpixel rendering is enabled on all ports.
168         mutableStyle().setDirection(LTR);
169     }
170
171     RenderBox* thumb = input.sliderThumbElement() ? input.sliderThumbElement()->renderBox() : nullptr;
172     RenderBox* track = input.sliderTrackElement() ? input.sliderTrackElement()->renderBox() : nullptr;
173     // Force a layout to reset the position of the thumb so the code below doesn't move the thumb to the wrong place.
174     // FIXME: Make a custom Render class for the track and move the thumb positioning code there.
175     if (track)
176         track->setChildNeedsLayout(MarkOnlyThis);
177
178     RenderFlexibleBox::layout();
179
180     mutableStyle().setDirection(oldTextDirection);
181     // These should always exist, unless someone mutates the shadow DOM (e.g., in the inspector).
182     if (!thumb || !track)
183         return;
184
185     double percentageOffset = sliderPosition(input).toDouble();
186     LayoutUnit availableExtent = isVertical ? track->contentHeight() : track->contentWidth();
187     availableExtent -= isVertical ? thumb->height() : thumb->width();
188     LayoutUnit offset = percentageOffset * availableExtent;
189     LayoutPoint thumbLocation = thumb->location();
190     if (isVertical)
191         thumbLocation.setY(thumbLocation.y() + track->contentHeight() - thumb->height() - offset);
192     else if (style().isLeftToRightDirection())
193         thumbLocation.setX(thumbLocation.x() + offset);
194     else
195         thumbLocation.setX(thumbLocation.x() - offset);
196     thumb->setLocation(thumbLocation);
197     thumb->repaint();
198 }
199
200 // --------------------------------
201
202 SliderThumbElement::SliderThumbElement(Document& document)
203     : HTMLDivElement(HTMLNames::divTag, document)
204     , m_inDragMode(false)
205 #if ENABLE(IOS_TOUCH_EVENTS)
206     , m_exclusiveTouchIdentifier(NoIdentifier)
207     , m_isRegisteredAsTouchEventListener(false)
208 #endif
209 {
210     setHasCustomStyleResolveCallbacks();
211 }
212
213 void SliderThumbElement::setPositionFromValue()
214 {
215     // Since the code to calculate position is in the RenderSliderThumb layout
216     // path, we don't actually update the value here. Instead, we poke at the
217     // renderer directly to trigger layout.
218     if (renderer())
219         renderer()->setNeedsLayout();
220 }
221
222 RenderPtr<RenderElement> SliderThumbElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
223 {
224     return createRenderer<RenderSliderThumb>(*this, WTFMove(style));
225 }
226
227 bool SliderThumbElement::isDisabledFormControl() const
228 {
229     HTMLInputElement* input = hostInput();
230     return !input || input->isDisabledFormControl();
231 }
232
233 bool SliderThumbElement::matchesReadWritePseudoClass() const
234 {
235     HTMLInputElement* input = hostInput();
236     return input && input->matchesReadWritePseudoClass();
237 }
238
239 Element* SliderThumbElement::focusDelegate()
240 {
241     return hostInput();
242 }
243
244 void SliderThumbElement::dragFrom(const LayoutPoint& point)
245 {
246     Ref<SliderThumbElement> protectedThis(*this);
247     setPositionFromPoint(point);
248 #if !PLATFORM(IOS)
249     startDragging();
250 #endif
251 }
252
253 void SliderThumbElement::setPositionFromPoint(const LayoutPoint& absolutePoint)
254 {
255     RefPtr<HTMLInputElement> input = hostInput();
256     if (!input)
257         return;
258
259     auto* inputRenderer = input->renderBox();
260     if (!inputRenderer)
261         return;
262
263     auto* thumbRenderer = renderBox();
264     if (!thumbRenderer)
265         return;
266
267     ASSERT(input->sliderTrackElement());
268     auto* trackRenderer = input->sliderTrackElement()->renderBox();
269     if (!trackRenderer)
270         return;
271
272     // Do all the tracking math relative to the input's renderer's box.
273
274     bool isVertical = hasVerticalAppearance(*input);
275     bool isLeftToRightDirection = thumbRenderer->style().isLeftToRightDirection();
276     
277     auto offset = inputRenderer->absoluteToLocal(absolutePoint, UseTransforms);
278     auto trackBoundingBox = trackRenderer->localToContainerQuad(FloatRect { { }, trackRenderer->size() }, inputRenderer).enclosingBoundingBox();
279
280     LayoutUnit trackLength;
281     LayoutUnit position;
282     if (isVertical) {
283         trackLength = trackRenderer->contentHeight() - thumbRenderer->height();
284         position = offset.y() - thumbRenderer->height() / 2 - trackBoundingBox.y() - thumbRenderer->marginBottom();
285     } else {
286         trackLength = trackRenderer->contentWidth() - thumbRenderer->width();
287         position = offset.x() - thumbRenderer->width() / 2 - trackBoundingBox.x();
288         position -= isLeftToRightDirection ? thumbRenderer->marginLeft() : thumbRenderer->marginRight();
289     }
290
291     position = std::max<LayoutUnit>(0, std::min(position, trackLength));
292     auto ratio = Decimal::fromDouble(static_cast<double>(position) / trackLength);
293     auto fraction = isVertical || !isLeftToRightDirection ? Decimal(1) - ratio : ratio;
294     auto stepRange = input->createStepRange(RejectAny);
295     auto value = stepRange.clampValue(stepRange.valueFromProportion(fraction));
296
297 #if ENABLE(DATALIST_ELEMENT)
298     const LayoutUnit snappingThreshold = renderer()->theme().sliderTickSnappingThreshold();
299     if (snappingThreshold > 0) {
300         if (std::optional<Decimal> closest = input->findClosestTickMarkValue(value)) {
301             double closestFraction = stepRange.proportionFromValue(*closest).toDouble();
302             double closestRatio = isVertical || !isLeftToRightDirection ? 1.0 - closestFraction : closestFraction;
303             LayoutUnit closestPosition = trackLength * closestRatio;
304             if ((closestPosition - position).abs() <= snappingThreshold)
305                 value = *closest;
306         }
307     }
308 #endif
309
310     String valueString = serializeForNumberType(value);
311     if (valueString == input->value())
312         return;
313
314     // FIXME: This is no longer being set from renderer. Consider updating the method name.
315     input->setValueFromRenderer(valueString);
316     if (renderer())
317         renderer()->setNeedsLayout();
318 }
319
320 void SliderThumbElement::startDragging()
321 {
322     if (Frame* frame = document().frame()) {
323         frame->eventHandler().setCapturingMouseEventsElement(this);
324         m_inDragMode = true;
325     }
326 }
327
328 void SliderThumbElement::stopDragging()
329 {
330     if (!m_inDragMode)
331         return;
332
333     if (Frame* frame = document().frame())
334         frame->eventHandler().setCapturingMouseEventsElement(nullptr);
335     m_inDragMode = false;
336     if (renderer())
337         renderer()->setNeedsLayout();
338 }
339
340 #if !PLATFORM(IOS)
341 void SliderThumbElement::defaultEventHandler(Event& event)
342 {
343     if (!is<MouseEvent>(event)) {
344         HTMLDivElement::defaultEventHandler(event);
345         return;
346     }
347
348     // FIXME: Should handle this readonly/disabled check in more general way.
349     // Missing this kind of check is likely to occur elsewhere if adding it in each shadow element.
350     HTMLInputElement* input = hostInput();
351     if (!input || input->isDisabledFormControl()) {
352         HTMLDivElement::defaultEventHandler(event);
353         return;
354     }
355
356     MouseEvent& mouseEvent = downcast<MouseEvent>(event);
357     bool isLeftButton = mouseEvent.button() == LeftButton;
358     const AtomicString& eventType = mouseEvent.type();
359
360     // We intentionally do not call event->setDefaultHandled() here because
361     // MediaControlTimelineElement::defaultEventHandler() wants to handle these
362     // mouse events.
363     if (eventType == eventNames().mousedownEvent && isLeftButton) {
364         startDragging();
365         return;
366     } else if (eventType == eventNames().mouseupEvent && isLeftButton) {
367         input->dispatchFormControlChangeEvent();
368         stopDragging();
369         return;
370     } else if (eventType == eventNames().mousemoveEvent) {
371         if (m_inDragMode)
372             setPositionFromPoint(mouseEvent.absoluteLocation());
373         return;
374     }
375
376     HTMLDivElement::defaultEventHandler(mouseEvent);
377 }
378 #endif
379
380 #if !PLATFORM(IOS)
381 bool SliderThumbElement::willRespondToMouseMoveEvents()
382 {
383     const HTMLInputElement* input = hostInput();
384     if (input && !input->isDisabledFormControl() && m_inDragMode)
385         return true;
386
387     return HTMLDivElement::willRespondToMouseMoveEvents();
388 }
389
390 bool SliderThumbElement::willRespondToMouseClickEvents()
391 {
392     const HTMLInputElement* input = hostInput();
393     if (input && !input->isDisabledFormControl())
394         return true;
395
396     return HTMLDivElement::willRespondToMouseClickEvents();
397 }
398 #endif // !PLATFORM(IOS)
399
400 void SliderThumbElement::willDetachRenderers()
401 {
402     if (m_inDragMode) {
403         if (Frame* frame = document().frame())
404             frame->eventHandler().setCapturingMouseEventsElement(nullptr);
405     }
406 #if ENABLE(IOS_TOUCH_EVENTS)
407     unregisterForTouchEvents();
408 #endif
409 }
410
411 #if ENABLE(IOS_TOUCH_EVENTS)
412 unsigned SliderThumbElement::exclusiveTouchIdentifier() const
413 {
414     return m_exclusiveTouchIdentifier;
415 }
416
417 void SliderThumbElement::setExclusiveTouchIdentifier(unsigned identifier)
418 {
419     ASSERT(m_exclusiveTouchIdentifier == NoIdentifier);
420     m_exclusiveTouchIdentifier = identifier;
421 }
422
423 void SliderThumbElement::clearExclusiveTouchIdentifier()
424 {
425     m_exclusiveTouchIdentifier = NoIdentifier;
426 }
427
428 static Touch* findTouchWithIdentifier(TouchList& list, unsigned identifier)
429 {
430     unsigned length = list.length();
431     for (unsigned i = 0; i < length; ++i) {
432         Touch* touch = list.item(i);
433         if (touch->identifier() == identifier)
434             return touch;
435     }
436     return nullptr;
437 }
438
439 void SliderThumbElement::handleTouchStart(TouchEvent& touchEvent)
440 {
441     TouchList* targetTouches = touchEvent.targetTouches();
442     if (!targetTouches)
443         return;
444
445     if (targetTouches->length() != 1)
446         return;
447
448     Touch* touch = targetTouches->item(0);
449     if (!renderer())
450         return;
451     IntRect boundingBox = renderer()->absoluteBoundingBoxRect();
452     // Ignore the touch if it is not really inside the thumb.
453     if (!boundingBox.contains(touch->pageX(), touch->pageY()))
454         return;
455
456     setExclusiveTouchIdentifier(touch->identifier());
457
458     startDragging();
459     touchEvent.setDefaultHandled();
460 }
461
462 void SliderThumbElement::handleTouchMove(TouchEvent& touchEvent)
463 {
464     unsigned identifier = exclusiveTouchIdentifier();
465     if (identifier == NoIdentifier)
466         return;
467
468     TouchList* targetTouches = touchEvent.targetTouches();
469     if (!targetTouches)
470         return;
471
472     Touch* touch = findTouchWithIdentifier(*targetTouches, identifier);
473     if (!touch)
474         return;
475
476     if (m_inDragMode)
477         setPositionFromPoint(IntPoint(touch->pageX(), touch->pageY()));
478     touchEvent.setDefaultHandled();
479 }
480
481 void SliderThumbElement::handleTouchEndAndCancel(TouchEvent& touchEvent)
482 {
483     unsigned identifier = exclusiveTouchIdentifier();
484     if (identifier == NoIdentifier)
485         return;
486
487     TouchList* targetTouches = touchEvent.targetTouches();
488     if (!targetTouches)
489         return;
490     // If our exclusive touch still exists, it was not the touch
491     // that ended, so we should not stop dragging.
492     Touch* exclusiveTouch = findTouchWithIdentifier(*targetTouches, identifier);
493     if (exclusiveTouch)
494         return;
495
496     clearExclusiveTouchIdentifier();
497
498     RefPtr<HTMLInputElement> input = hostInput();
499     if (input)
500         input->dispatchFormControlChangeEvent();
501     stopDragging();
502 }
503
504 void SliderThumbElement::didAttachRenderers()
505 {
506     if (shouldAcceptTouchEvents())
507         registerForTouchEvents();
508 }
509
510 void SliderThumbElement::handleTouchEvent(TouchEvent& touchEvent)
511 {
512     HTMLInputElement* input = hostInput();
513     ASSERT(input);
514     if (input->isReadOnly() || input->isDisabledFormControl()) {
515         clearExclusiveTouchIdentifier();
516         stopDragging();
517         touchEvent.setDefaultHandled();
518         HTMLDivElement::defaultEventHandler(touchEvent);
519         return;
520     }
521
522     const AtomicString& eventType = touchEvent.type();
523     if (eventType == eventNames().touchstartEvent) {
524         handleTouchStart(touchEvent);
525         return;
526     }
527     if (eventType == eventNames().touchendEvent || eventType == eventNames().touchcancelEvent) {
528         handleTouchEndAndCancel(touchEvent);
529         return;
530     }
531     if (eventType == eventNames().touchmoveEvent) {
532         handleTouchMove(touchEvent);
533         return;
534     }
535
536     HTMLDivElement::defaultEventHandler(touchEvent);
537 }
538
539 bool SliderThumbElement::shouldAcceptTouchEvents()
540 {
541     return renderer() && !isDisabledFormControl();
542 }
543
544 void SliderThumbElement::registerForTouchEvents()
545 {
546     if (m_isRegisteredAsTouchEventListener)
547         return;
548
549     ASSERT(shouldAcceptTouchEvents());
550
551     document().addTouchEventHandler(*this);
552     m_isRegisteredAsTouchEventListener = true;
553 }
554
555 void SliderThumbElement::unregisterForTouchEvents()
556 {
557     if (!m_isRegisteredAsTouchEventListener)
558         return;
559
560     clearExclusiveTouchIdentifier();
561     stopDragging();
562
563     document().removeTouchEventHandler(*this);
564     m_isRegisteredAsTouchEventListener = false;
565 }
566 #endif // ENABLE(IOS_TOUCH_EVENTS)
567
568 void SliderThumbElement::disabledAttributeChanged()
569 {
570     if (isDisabledFormControl())
571         stopDragging();
572
573 #if ENABLE(IOS_TOUCH_EVENTS)
574     if (shouldAcceptTouchEvents())
575         registerForTouchEvents();
576     else
577         unregisterForTouchEvents();
578 #endif
579 }
580
581 HTMLInputElement* SliderThumbElement::hostInput() const
582 {
583     // Only HTMLInputElement creates SliderThumbElement instances as its shadow nodes.
584     // So, shadowHost() must be an HTMLInputElement.
585     return downcast<HTMLInputElement>(shadowHost());
586 }
587
588 std::optional<ElementStyle> SliderThumbElement::resolveCustomStyle(const RenderStyle&, const RenderStyle* hostStyle)
589 {
590     // This doesn't actually compute style. This is just a hack to pick shadow pseudo id when host style is known.
591
592     static NeverDestroyed<const AtomicString> sliderThumbShadowPseudoId("-webkit-slider-thumb", AtomicString::ConstructFromLiteral);
593     static NeverDestroyed<const AtomicString> mediaSliderThumbShadowPseudoId("-webkit-media-slider-thumb", AtomicString::ConstructFromLiteral);
594
595     if (!hostStyle)
596         return std::nullopt;
597
598     switch (hostStyle->appearance()) {
599     case MediaSliderPart:
600     case MediaSliderThumbPart:
601     case MediaVolumeSliderPart:
602     case MediaVolumeSliderThumbPart:
603     case MediaFullScreenVolumeSliderPart:
604     case MediaFullScreenVolumeSliderThumbPart:
605         m_shadowPseudoId = mediaSliderThumbShadowPseudoId;
606         break;
607     default:
608         m_shadowPseudoId = sliderThumbShadowPseudoId;
609     }
610
611     return std::nullopt;
612 }
613
614 const AtomicString& SliderThumbElement::shadowPseudoId() const
615 {
616     return m_shadowPseudoId;
617 }
618
619 Ref<Element> SliderThumbElement::cloneElementWithoutAttributesAndChildren(Document& targetDocument)
620 {
621     return create(targetDocument);
622 }
623
624 // --------------------------------
625
626 inline SliderContainerElement::SliderContainerElement(Document& document)
627     : HTMLDivElement(HTMLNames::divTag, document)
628 {
629     setHasCustomStyleResolveCallbacks();
630 }
631
632 Ref<SliderContainerElement> SliderContainerElement::create(Document& document)
633 {
634     return adoptRef(*new SliderContainerElement(document));
635 }
636
637 RenderPtr<RenderElement> SliderContainerElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
638 {
639     return createRenderer<RenderSliderContainer>(*this, WTFMove(style));
640 }
641
642 std::optional<ElementStyle> SliderContainerElement::resolveCustomStyle(const RenderStyle&, const RenderStyle* hostStyle)
643 {
644     // This doesn't actually compute style. This is just a hack to pick shadow pseudo id when host style is known.
645
646     static NeverDestroyed<const AtomicString> mediaSliderContainer("-webkit-media-slider-container", AtomicString::ConstructFromLiteral);
647     static NeverDestroyed<const AtomicString> sliderContainer("-webkit-slider-container", AtomicString::ConstructFromLiteral);
648
649     if (!hostStyle)
650         return std::nullopt;
651
652     switch (hostStyle->appearance()) {
653     case MediaSliderPart:
654     case MediaSliderThumbPart:
655     case MediaVolumeSliderPart:
656     case MediaVolumeSliderThumbPart:
657     case MediaFullScreenVolumeSliderPart:
658     case MediaFullScreenVolumeSliderThumbPart:
659         m_shadowPseudoId = mediaSliderContainer;
660         break;
661     default:
662         m_shadowPseudoId = sliderContainer;
663     }
664
665     return std::nullopt;
666 }
667
668 const AtomicString& SliderContainerElement::shadowPseudoId() const
669 {
670     return m_shadowPseudoId;
671 }
672
673 }