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 }