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 }