7af7e71b1d84dfd731bc4ac9fc734336ac38c95a
[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     void computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit logicalTop, LogicalExtentComputedValues&) const override;
123
124 private:
125     void layout() override;
126     bool isFlexibleBoxImpl() const override { return true; }
127 };
128
129 void RenderSliderContainer::computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit logicalTop, LogicalExtentComputedValues& computedValues) 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         RenderBox::computeLogicalHeight(trackHeight, logicalTop, computedValues);
150         return;
151     }
152 #endif
153     if (isVertical)
154         logicalHeight = RenderSlider::defaultTrackLength;
155     RenderBox::computeLogicalHeight(logicalHeight, logicalTop, computedValues);
156 }
157
158 void RenderSliderContainer::layout()
159 {
160     ASSERT(element()->shadowHost());
161     auto& input = downcast<HTMLInputElement>(*element()->shadowHost());
162     bool isVertical = hasVerticalAppearance(input);
163     mutableStyle().setFlexDirection(isVertical ? FlowColumn : FlowRow);
164     TextDirection oldTextDirection = style().direction();
165     if (isVertical) {
166         // FIXME: Work around rounding issues in RTL vertical sliders. We want them to
167         // render identically to LTR vertical sliders. We can remove this work around when
168         // subpixel rendering is enabled on all ports.
169         mutableStyle().setDirection(LTR);
170     }
171
172     RenderBox* thumb = input.sliderThumbElement() ? input.sliderThumbElement()->renderBox() : nullptr;
173     RenderBox* track = input.sliderTrackElement() ? input.sliderTrackElement()->renderBox() : nullptr;
174     // Force a layout to reset the position of the thumb so the code below doesn't move the thumb to the wrong place.
175     // FIXME: Make a custom Render class for the track and move the thumb positioning code there.
176     if (track)
177         track->setChildNeedsLayout(MarkOnlyThis);
178
179     RenderFlexibleBox::layout();
180
181     mutableStyle().setDirection(oldTextDirection);
182     // These should always exist, unless someone mutates the shadow DOM (e.g., in the inspector).
183     if (!thumb || !track)
184         return;
185
186     double percentageOffset = sliderPosition(input).toDouble();
187     LayoutUnit availableExtent = isVertical ? track->contentHeight() : track->contentWidth();
188     availableExtent -= isVertical ? thumb->height() : thumb->width();
189     LayoutUnit offset = percentageOffset * availableExtent;
190     LayoutPoint thumbLocation = thumb->location();
191     if (isVertical)
192         thumbLocation.setY(thumbLocation.y() + track->contentHeight() - thumb->height() - offset);
193     else if (style().isLeftToRightDirection())
194         thumbLocation.setX(thumbLocation.x() + offset);
195     else
196         thumbLocation.setX(thumbLocation.x() - offset);
197     thumb->setLocation(thumbLocation);
198     thumb->repaint();
199 }
200
201 // --------------------------------
202
203 SliderThumbElement::SliderThumbElement(Document& document)
204     : HTMLDivElement(HTMLNames::divTag, document)
205     , m_inDragMode(false)
206 #if ENABLE(IOS_TOUCH_EVENTS)
207     , m_exclusiveTouchIdentifier(NoIdentifier)
208     , m_isRegisteredAsTouchEventListener(false)
209 #endif
210 {
211     setHasCustomStyleResolveCallbacks();
212 }
213
214 void SliderThumbElement::setPositionFromValue()
215 {
216     // Since the code to calculate position is in the RenderSliderThumb layout
217     // path, we don't actually update the value here. Instead, we poke at the
218     // renderer directly to trigger layout.
219     if (renderer())
220         renderer()->setNeedsLayout();
221 }
222
223 RenderPtr<RenderElement> SliderThumbElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
224 {
225     return createRenderer<RenderSliderThumb>(*this, WTFMove(style));
226 }
227
228 bool SliderThumbElement::isDisabledFormControl() const
229 {
230     HTMLInputElement* input = hostInput();
231     return !input || input->isDisabledFormControl();
232 }
233
234 bool SliderThumbElement::matchesReadWritePseudoClass() const
235 {
236     HTMLInputElement* input = hostInput();
237     return input && input->matchesReadWritePseudoClass();
238 }
239
240 Element* SliderThumbElement::focusDelegate()
241 {
242     return hostInput();
243 }
244
245 void SliderThumbElement::dragFrom(const LayoutPoint& point)
246 {
247     Ref<SliderThumbElement> protectedThis(*this);
248     setPositionFromPoint(point);
249 #if !PLATFORM(IOS)
250     startDragging();
251 #endif
252 }
253
254 void SliderThumbElement::setPositionFromPoint(const LayoutPoint& absolutePoint)
255 {
256     RefPtr<HTMLInputElement> input = hostInput();
257     if (!input)
258         return;
259
260     auto* inputRenderer = input->renderBox();
261     if (!inputRenderer)
262         return;
263
264     auto* thumbRenderer = renderBox();
265     if (!thumbRenderer)
266         return;
267
268     ASSERT(input->sliderTrackElement());
269     auto* trackRenderer = input->sliderTrackElement()->renderBox();
270     if (!trackRenderer)
271         return;
272
273     // Do all the tracking math relative to the input's renderer's box.
274
275     bool isVertical = hasVerticalAppearance(*input);
276     bool isLeftToRightDirection = thumbRenderer->style().isLeftToRightDirection();
277     
278     auto offset = inputRenderer->absoluteToLocal(absolutePoint, UseTransforms);
279     auto trackBoundingBox = trackRenderer->localToContainerQuad(FloatRect { { }, trackRenderer->size() }, inputRenderer).enclosingBoundingBox();
280
281     LayoutUnit trackLength;
282     LayoutUnit position;
283     if (isVertical) {
284         trackLength = trackRenderer->contentHeight() - thumbRenderer->height();
285         position = offset.y() - thumbRenderer->height() / 2 - trackBoundingBox.y() - thumbRenderer->marginBottom();
286     } else {
287         trackLength = trackRenderer->contentWidth() - thumbRenderer->width();
288         position = offset.x() - thumbRenderer->width() / 2 - trackBoundingBox.x();
289         position -= isLeftToRightDirection ? thumbRenderer->marginLeft() : thumbRenderer->marginRight();
290     }
291
292     position = std::max<LayoutUnit>(0, std::min(position, trackLength));
293     auto ratio = Decimal::fromDouble(static_cast<double>(position) / trackLength);
294     auto fraction = isVertical || !isLeftToRightDirection ? Decimal(1) - ratio : ratio;
295     auto stepRange = input->createStepRange(RejectAny);
296     auto value = stepRange.clampValue(stepRange.valueFromProportion(fraction));
297
298 #if ENABLE(DATALIST_ELEMENT)
299     const LayoutUnit snappingThreshold = renderer()->theme().sliderTickSnappingThreshold();
300     if (snappingThreshold > 0) {
301         if (Optional<Decimal> closest = input->findClosestTickMarkValue(value)) {
302             double closestFraction = stepRange.proportionFromValue(*closest).toDouble();
303             double closestRatio = isVertical || !isLeftToRightDirection ? 1.0 - closestFraction : closestFraction;
304             LayoutUnit closestPosition = trackLength * closestRatio;
305             if ((closestPosition - position).abs() <= snappingThreshold)
306                 value = *closest;
307         }
308     }
309 #endif
310
311     String valueString = serializeForNumberType(value);
312     if (valueString == input->value())
313         return;
314
315     // FIXME: This is no longer being set from renderer. Consider updating the method name.
316     input->setValueFromRenderer(valueString);
317     if (renderer())
318         renderer()->setNeedsLayout();
319 }
320
321 void SliderThumbElement::startDragging()
322 {
323     if (Frame* frame = document().frame()) {
324         frame->eventHandler().setCapturingMouseEventsElement(this);
325         m_inDragMode = true;
326     }
327 }
328
329 void SliderThumbElement::stopDragging()
330 {
331     if (!m_inDragMode)
332         return;
333
334     if (Frame* frame = document().frame())
335         frame->eventHandler().setCapturingMouseEventsElement(nullptr);
336     m_inDragMode = false;
337     if (renderer())
338         renderer()->setNeedsLayout();
339
340     RefPtr<HTMLInputElement> input = hostInput();
341     if (input)
342         input->dispatchFormControlChangeEvent();
343 }
344
345 #if !PLATFORM(IOS)
346 void SliderThumbElement::defaultEventHandler(Event* event)
347 {
348     if (!is<MouseEvent>(*event)) {
349         HTMLDivElement::defaultEventHandler(event);
350         return;
351     }
352
353     // FIXME: Should handle this readonly/disabled check in more general way.
354     // Missing this kind of check is likely to occur elsewhere if adding it in each shadow element.
355     HTMLInputElement* input = hostInput();
356     if (!input || input->isDisabledOrReadOnly()) {
357         stopDragging();
358         HTMLDivElement::defaultEventHandler(event);
359         return;
360     }
361
362     MouseEvent& mouseEvent = downcast<MouseEvent>(*event);
363     bool isLeftButton = mouseEvent.button() == LeftButton;
364     const AtomicString& eventType = mouseEvent.type();
365
366     // We intentionally do not call event->setDefaultHandled() here because
367     // MediaControlTimelineElement::defaultEventHandler() wants to handle these
368     // mouse events.
369     if (eventType == eventNames().mousedownEvent && isLeftButton) {
370         startDragging();
371         return;
372     } else if (eventType == eventNames().mouseupEvent && isLeftButton) {
373         stopDragging();
374         return;
375     } else if (eventType == eventNames().mousemoveEvent) {
376         if (m_inDragMode)
377             setPositionFromPoint(mouseEvent.absoluteLocation());
378         return;
379     }
380
381     HTMLDivElement::defaultEventHandler(&mouseEvent);
382 }
383 #endif
384
385 #if !PLATFORM(IOS)
386 bool SliderThumbElement::willRespondToMouseMoveEvents()
387 {
388     const HTMLInputElement* input = hostInput();
389     if (input && !input->isDisabledOrReadOnly() && m_inDragMode)
390         return true;
391
392     return HTMLDivElement::willRespondToMouseMoveEvents();
393 }
394
395 bool SliderThumbElement::willRespondToMouseClickEvents()
396 {
397     const HTMLInputElement* input = hostInput();
398     if (input && !input->isDisabledOrReadOnly())
399         return true;
400
401     return HTMLDivElement::willRespondToMouseClickEvents();
402 }
403 #endif // !PLATFORM(IOS)
404
405 void SliderThumbElement::willDetachRenderers()
406 {
407     if (m_inDragMode) {
408         if (Frame* frame = document().frame())
409             frame->eventHandler().setCapturingMouseEventsElement(nullptr);
410     }
411 #if ENABLE(IOS_TOUCH_EVENTS)
412     unregisterForTouchEvents();
413 #endif
414 }
415
416 #if ENABLE(IOS_TOUCH_EVENTS)
417 unsigned SliderThumbElement::exclusiveTouchIdentifier() const
418 {
419     return m_exclusiveTouchIdentifier;
420 }
421
422 void SliderThumbElement::setExclusiveTouchIdentifier(unsigned identifier)
423 {
424     ASSERT(m_exclusiveTouchIdentifier == NoIdentifier);
425     m_exclusiveTouchIdentifier = identifier;
426 }
427
428 void SliderThumbElement::clearExclusiveTouchIdentifier()
429 {
430     m_exclusiveTouchIdentifier = NoIdentifier;
431 }
432
433 static Touch* findTouchWithIdentifier(TouchList& list, unsigned identifier)
434 {
435     unsigned length = list.length();
436     for (unsigned i = 0; i < length; ++i) {
437         Touch* touch = list.item(i);
438         if (touch->identifier() == identifier)
439             return touch;
440     }
441     return nullptr;
442 }
443
444 void SliderThumbElement::handleTouchStart(TouchEvent* touchEvent)
445 {
446     TouchList* targetTouches = touchEvent->targetTouches();
447     if (!targetTouches)
448         return;
449
450     if (targetTouches->length() != 1)
451         return;
452
453     Touch* touch = targetTouches->item(0);
454     if (!renderer())
455         return;
456     IntRect boundingBox = renderer()->absoluteBoundingBoxRect();
457     // Ignore the touch if it is not really inside the thumb.
458     if (!boundingBox.contains(touch->pageX(), touch->pageY()))
459         return;
460
461     setExclusiveTouchIdentifier(touch->identifier());
462
463     startDragging();
464     touchEvent->setDefaultHandled();
465 }
466
467 void SliderThumbElement::handleTouchMove(TouchEvent* touchEvent)
468 {
469     unsigned identifier = exclusiveTouchIdentifier();
470     if (identifier == NoIdentifier)
471         return;
472
473     TouchList* targetTouches = touchEvent->targetTouches();
474     if (!targetTouches)
475         return;
476
477     Touch* touch = findTouchWithIdentifier(*targetTouches, identifier);
478     if (!touch)
479         return;
480
481     if (m_inDragMode)
482         setPositionFromPoint(IntPoint(touch->pageX(), touch->pageY()));
483     touchEvent->setDefaultHandled();
484 }
485
486 void SliderThumbElement::handleTouchEndAndCancel(TouchEvent* touchEvent)
487 {
488     unsigned identifier = exclusiveTouchIdentifier();
489     if (identifier == NoIdentifier)
490         return;
491
492     TouchList* targetTouches = touchEvent->targetTouches();
493     if (!targetTouches)
494         return;
495     // If our exclusive touch still exists, it was not the touch
496     // that ended, so we should not stop dragging.
497     Touch* exclusiveTouch = findTouchWithIdentifier(*targetTouches, identifier);
498     if (exclusiveTouch)
499         return;
500
501     clearExclusiveTouchIdentifier();
502
503     stopDragging();
504 }
505
506 void SliderThumbElement::didAttachRenderers()
507 {
508     if (shouldAcceptTouchEvents())
509         registerForTouchEvents();
510 }
511
512 void SliderThumbElement::handleTouchEvent(TouchEvent* touchEvent)
513 {
514     HTMLInputElement* input = hostInput();
515     ASSERT(input);
516     if (input->isReadOnly() || input->isDisabledFormControl()) {
517         clearExclusiveTouchIdentifier();
518         stopDragging();
519         touchEvent->setDefaultHandled();
520         HTMLDivElement::defaultEventHandler(touchEvent);
521         return;
522     }
523
524     const AtomicString& eventType = touchEvent->type();
525     if (eventType == eventNames().touchstartEvent) {
526         handleTouchStart(touchEvent);
527         return;
528     }
529     if (eventType == eventNames().touchendEvent || eventType == eventNames().touchcancelEvent) {
530         handleTouchEndAndCancel(touchEvent);
531         return;
532     }
533     if (eventType == eventNames().touchmoveEvent) {
534         handleTouchMove(touchEvent);
535         return;
536     }
537
538     HTMLDivElement::defaultEventHandler(touchEvent);
539 }
540
541 bool SliderThumbElement::shouldAcceptTouchEvents()
542 {
543     return renderer() && !isDisabledFormControl();
544 }
545
546 void SliderThumbElement::registerForTouchEvents()
547 {
548     if (m_isRegisteredAsTouchEventListener)
549         return;
550
551     ASSERT(shouldAcceptTouchEvents());
552
553     document().addTouchEventHandler(this);
554     m_isRegisteredAsTouchEventListener = true;
555 }
556
557 void SliderThumbElement::unregisterForTouchEvents()
558 {
559     if (!m_isRegisteredAsTouchEventListener)
560         return;
561
562     clearExclusiveTouchIdentifier();
563     stopDragging();
564
565     document().removeTouchEventHandler(this);
566     m_isRegisteredAsTouchEventListener = false;
567 }
568
569 void SliderThumbElement::disabledAttributeChanged()
570 {
571     if (shouldAcceptTouchEvents())
572         registerForTouchEvents();
573     else
574         unregisterForTouchEvents();
575 }
576 #endif // ENABLE(IOS_TOUCH_EVENTS)
577
578 HTMLInputElement* SliderThumbElement::hostInput() const
579 {
580     // Only HTMLInputElement creates SliderThumbElement instances as its shadow nodes.
581     // So, shadowHost() must be an HTMLInputElement.
582     return downcast<HTMLInputElement>(shadowHost());
583 }
584
585 Optional<ElementStyle> SliderThumbElement::resolveCustomStyle(const RenderStyle&, const RenderStyle* hostStyle)
586 {
587     // This doesn't actually compute style. This is just a hack to pick shadow pseudo id when host style is known.
588
589     static NeverDestroyed<const AtomicString> sliderThumbShadowPseudoId("-webkit-slider-thumb", AtomicString::ConstructFromLiteral);
590     static NeverDestroyed<const AtomicString> mediaSliderThumbShadowPseudoId("-webkit-media-slider-thumb", AtomicString::ConstructFromLiteral);
591
592     if (!hostStyle)
593         return Nullopt;
594
595     switch (hostStyle->appearance()) {
596     case MediaSliderPart:
597     case MediaSliderThumbPart:
598     case MediaVolumeSliderPart:
599     case MediaVolumeSliderThumbPart:
600     case MediaFullScreenVolumeSliderPart:
601     case MediaFullScreenVolumeSliderThumbPart:
602         m_shadowPseudoId = mediaSliderThumbShadowPseudoId;
603         break;
604     default:
605         m_shadowPseudoId = sliderThumbShadowPseudoId;
606     }
607
608     return Nullopt;
609 }
610
611 const AtomicString& SliderThumbElement::shadowPseudoId() const
612 {
613     return m_shadowPseudoId;
614 }
615
616 Ref<Element> SliderThumbElement::cloneElementWithoutAttributesAndChildren(Document& targetDocument)
617 {
618     return create(targetDocument);
619 }
620
621 // --------------------------------
622
623 inline SliderContainerElement::SliderContainerElement(Document& document)
624     : HTMLDivElement(HTMLNames::divTag, document)
625 {
626     setHasCustomStyleResolveCallbacks();
627 }
628
629 Ref<SliderContainerElement> SliderContainerElement::create(Document& document)
630 {
631     return adoptRef(*new SliderContainerElement(document));
632 }
633
634 RenderPtr<RenderElement> SliderContainerElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
635 {
636     return createRenderer<RenderSliderContainer>(*this, WTFMove(style));
637 }
638
639 Optional<ElementStyle> SliderContainerElement::resolveCustomStyle(const RenderStyle&, const RenderStyle* hostStyle)
640 {
641     // This doesn't actually compute style. This is just a hack to pick shadow pseudo id when host style is known.
642
643     static NeverDestroyed<const AtomicString> mediaSliderContainer("-webkit-media-slider-container", AtomicString::ConstructFromLiteral);
644     static NeverDestroyed<const AtomicString> sliderContainer("-webkit-slider-container", AtomicString::ConstructFromLiteral);
645
646     if (!hostStyle)
647         return Nullopt;
648
649     switch (hostStyle->appearance()) {
650     case MediaSliderPart:
651     case MediaSliderThumbPart:
652     case MediaVolumeSliderPart:
653     case MediaVolumeSliderThumbPart:
654     case MediaFullScreenVolumeSliderPart:
655     case MediaFullScreenVolumeSliderThumbPart:
656         m_shadowPseudoId = mediaSliderContainer;
657         break;
658     default:
659         m_shadowPseudoId = sliderContainer;
660     }
661
662     return Nullopt;
663 }
664
665 const AtomicString& SliderContainerElement::shadowPseudoId() const
666 {
667     return m_shadowPseudoId;
668 }
669
670 }