27f138b39e27ee9e363283e6fe08e21ff082e8ef
[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         stopDragging();
353         HTMLDivElement::defaultEventHandler(event);
354         return;
355     }
356
357     MouseEvent& mouseEvent = downcast<MouseEvent>(event);
358     bool isLeftButton = mouseEvent.button() == LeftButton;
359     const AtomicString& eventType = mouseEvent.type();
360
361     // We intentionally do not call event->setDefaultHandled() here because
362     // MediaControlTimelineElement::defaultEventHandler() wants to handle these
363     // mouse events.
364     if (eventType == eventNames().mousedownEvent && isLeftButton) {
365         startDragging();
366         return;
367     } else if (eventType == eventNames().mouseupEvent && isLeftButton) {
368         input->dispatchFormControlChangeEvent();
369         stopDragging();
370         return;
371     } else if (eventType == eventNames().mousemoveEvent) {
372         if (m_inDragMode)
373             setPositionFromPoint(mouseEvent.absoluteLocation());
374         return;
375     }
376
377     HTMLDivElement::defaultEventHandler(mouseEvent);
378 }
379 #endif
380
381 #if !PLATFORM(IOS)
382 bool SliderThumbElement::willRespondToMouseMoveEvents()
383 {
384     const HTMLInputElement* input = hostInput();
385     if (input && !input->isDisabledFormControl() && m_inDragMode)
386         return true;
387
388     return HTMLDivElement::willRespondToMouseMoveEvents();
389 }
390
391 bool SliderThumbElement::willRespondToMouseClickEvents()
392 {
393     const HTMLInputElement* input = hostInput();
394     if (input && !input->isDisabledFormControl())
395         return true;
396
397     return HTMLDivElement::willRespondToMouseClickEvents();
398 }
399 #endif // !PLATFORM(IOS)
400
401 void SliderThumbElement::willDetachRenderers()
402 {
403     if (m_inDragMode) {
404         if (Frame* frame = document().frame())
405             frame->eventHandler().setCapturingMouseEventsElement(nullptr);
406     }
407 #if ENABLE(IOS_TOUCH_EVENTS)
408     unregisterForTouchEvents();
409 #endif
410 }
411
412 #if ENABLE(IOS_TOUCH_EVENTS)
413 unsigned SliderThumbElement::exclusiveTouchIdentifier() const
414 {
415     return m_exclusiveTouchIdentifier;
416 }
417
418 void SliderThumbElement::setExclusiveTouchIdentifier(unsigned identifier)
419 {
420     ASSERT(m_exclusiveTouchIdentifier == NoIdentifier);
421     m_exclusiveTouchIdentifier = identifier;
422 }
423
424 void SliderThumbElement::clearExclusiveTouchIdentifier()
425 {
426     m_exclusiveTouchIdentifier = NoIdentifier;
427 }
428
429 static Touch* findTouchWithIdentifier(TouchList& list, unsigned identifier)
430 {
431     unsigned length = list.length();
432     for (unsigned i = 0; i < length; ++i) {
433         Touch* touch = list.item(i);
434         if (touch->identifier() == identifier)
435             return touch;
436     }
437     return nullptr;
438 }
439
440 void SliderThumbElement::handleTouchStart(TouchEvent& touchEvent)
441 {
442     TouchList* targetTouches = touchEvent.targetTouches();
443     if (!targetTouches)
444         return;
445
446     if (targetTouches->length() != 1)
447         return;
448
449     Touch* touch = targetTouches->item(0);
450     if (!renderer())
451         return;
452     IntRect boundingBox = renderer()->absoluteBoundingBoxRect();
453     // Ignore the touch if it is not really inside the thumb.
454     if (!boundingBox.contains(touch->pageX(), touch->pageY()))
455         return;
456
457     setExclusiveTouchIdentifier(touch->identifier());
458
459     startDragging();
460     touchEvent.setDefaultHandled();
461 }
462
463 void SliderThumbElement::handleTouchMove(TouchEvent& touchEvent)
464 {
465     unsigned identifier = exclusiveTouchIdentifier();
466     if (identifier == NoIdentifier)
467         return;
468
469     TouchList* targetTouches = touchEvent.targetTouches();
470     if (!targetTouches)
471         return;
472
473     Touch* touch = findTouchWithIdentifier(*targetTouches, identifier);
474     if (!touch)
475         return;
476
477     if (m_inDragMode)
478         setPositionFromPoint(IntPoint(touch->pageX(), touch->pageY()));
479     touchEvent.setDefaultHandled();
480 }
481
482 void SliderThumbElement::handleTouchEndAndCancel(TouchEvent& touchEvent)
483 {
484     unsigned identifier = exclusiveTouchIdentifier();
485     if (identifier == NoIdentifier)
486         return;
487
488     TouchList* targetTouches = touchEvent.targetTouches();
489     if (!targetTouches)
490         return;
491     // If our exclusive touch still exists, it was not the touch
492     // that ended, so we should not stop dragging.
493     Touch* exclusiveTouch = findTouchWithIdentifier(*targetTouches, identifier);
494     if (exclusiveTouch)
495         return;
496
497     clearExclusiveTouchIdentifier();
498
499     RefPtr<HTMLInputElement> input = hostInput();
500     if (input)
501         input->dispatchFormControlChangeEvent();
502     stopDragging();
503 }
504
505 void SliderThumbElement::didAttachRenderers()
506 {
507     if (shouldAcceptTouchEvents())
508         registerForTouchEvents();
509 }
510
511 void SliderThumbElement::handleTouchEvent(TouchEvent& touchEvent)
512 {
513     HTMLInputElement* input = hostInput();
514     ASSERT(input);
515     if (input->isReadOnly() || input->isDisabledFormControl()) {
516         clearExclusiveTouchIdentifier();
517         stopDragging();
518         touchEvent.setDefaultHandled();
519         HTMLDivElement::defaultEventHandler(touchEvent);
520         return;
521     }
522
523     const AtomicString& eventType = touchEvent.type();
524     if (eventType == eventNames().touchstartEvent) {
525         handleTouchStart(touchEvent);
526         return;
527     }
528     if (eventType == eventNames().touchendEvent || eventType == eventNames().touchcancelEvent) {
529         handleTouchEndAndCancel(touchEvent);
530         return;
531     }
532     if (eventType == eventNames().touchmoveEvent) {
533         handleTouchMove(touchEvent);
534         return;
535     }
536
537     HTMLDivElement::defaultEventHandler(touchEvent);
538 }
539
540 bool SliderThumbElement::shouldAcceptTouchEvents()
541 {
542     return renderer() && !isDisabledFormControl();
543 }
544
545 void SliderThumbElement::registerForTouchEvents()
546 {
547     if (m_isRegisteredAsTouchEventListener)
548         return;
549
550     ASSERT(shouldAcceptTouchEvents());
551
552     document().addTouchEventHandler(*this);
553     m_isRegisteredAsTouchEventListener = true;
554 }
555
556 void SliderThumbElement::unregisterForTouchEvents()
557 {
558     if (!m_isRegisteredAsTouchEventListener)
559         return;
560
561     clearExclusiveTouchIdentifier();
562     stopDragging();
563
564     document().removeTouchEventHandler(*this);
565     m_isRegisteredAsTouchEventListener = false;
566 }
567
568 void SliderThumbElement::disabledAttributeChanged()
569 {
570     if (shouldAcceptTouchEvents())
571         registerForTouchEvents();
572     else
573         unregisterForTouchEvents();
574 }
575 #endif // ENABLE(IOS_TOUCH_EVENTS)
576
577 HTMLInputElement* SliderThumbElement::hostInput() const
578 {
579     // Only HTMLInputElement creates SliderThumbElement instances as its shadow nodes.
580     // So, shadowHost() must be an HTMLInputElement.
581     return downcast<HTMLInputElement>(shadowHost());
582 }
583
584 std::optional<ElementStyle> SliderThumbElement::resolveCustomStyle(const RenderStyle&, const RenderStyle* hostStyle)
585 {
586     // This doesn't actually compute style. This is just a hack to pick shadow pseudo id when host style is known.
587
588     static NeverDestroyed<const AtomicString> sliderThumbShadowPseudoId("-webkit-slider-thumb", AtomicString::ConstructFromLiteral);
589     static NeverDestroyed<const AtomicString> mediaSliderThumbShadowPseudoId("-webkit-media-slider-thumb", AtomicString::ConstructFromLiteral);
590
591     if (!hostStyle)
592         return std::nullopt;
593
594     switch (hostStyle->appearance()) {
595     case MediaSliderPart:
596     case MediaSliderThumbPart:
597     case MediaVolumeSliderPart:
598     case MediaVolumeSliderThumbPart:
599     case MediaFullScreenVolumeSliderPart:
600     case MediaFullScreenVolumeSliderThumbPart:
601         m_shadowPseudoId = mediaSliderThumbShadowPseudoId;
602         break;
603     default:
604         m_shadowPseudoId = sliderThumbShadowPseudoId;
605     }
606
607     return std::nullopt;
608 }
609
610 const AtomicString& SliderThumbElement::shadowPseudoId() const
611 {
612     return m_shadowPseudoId;
613 }
614
615 Ref<Element> SliderThumbElement::cloneElementWithoutAttributesAndChildren(Document& targetDocument)
616 {
617     return create(targetDocument);
618 }
619
620 // --------------------------------
621
622 inline SliderContainerElement::SliderContainerElement(Document& document)
623     : HTMLDivElement(HTMLNames::divTag, document)
624 {
625     setHasCustomStyleResolveCallbacks();
626 }
627
628 Ref<SliderContainerElement> SliderContainerElement::create(Document& document)
629 {
630     return adoptRef(*new SliderContainerElement(document));
631 }
632
633 RenderPtr<RenderElement> SliderContainerElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
634 {
635     return createRenderer<RenderSliderContainer>(*this, WTFMove(style));
636 }
637
638 std::optional<ElementStyle> SliderContainerElement::resolveCustomStyle(const RenderStyle&, const RenderStyle* hostStyle)
639 {
640     // This doesn't actually compute style. This is just a hack to pick shadow pseudo id when host style is known.
641
642     static NeverDestroyed<const AtomicString> mediaSliderContainer("-webkit-media-slider-container", AtomicString::ConstructFromLiteral);
643     static NeverDestroyed<const AtomicString> sliderContainer("-webkit-slider-container", AtomicString::ConstructFromLiteral);
644
645     if (!hostStyle)
646         return std::nullopt;
647
648     switch (hostStyle->appearance()) {
649     case MediaSliderPart:
650     case MediaSliderThumbPart:
651     case MediaVolumeSliderPart:
652     case MediaVolumeSliderThumbPart:
653     case MediaFullScreenVolumeSliderPart:
654     case MediaFullScreenVolumeSliderThumbPart:
655         m_shadowPseudoId = mediaSliderContainer;
656         break;
657     default:
658         m_shadowPseudoId = sliderContainer;
659     }
660
661     return std::nullopt;
662 }
663
664 const AtomicString& SliderContainerElement::shadowPseudoId() const
665 {
666     return m_shadowPseudoId;
667 }
668
669 }