| /* |
| * Copyright (C) 2021-2022 Apple Inc. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, |
| * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS |
| * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF |
| * THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "config.h" |
| #include "ModalContainerObserver.h" |
| |
| #include "AccessibilityObject.h" |
| #include "Chrome.h" |
| #include "ChromeClient.h" |
| #include "Document.h" |
| #include "DocumentLoader.h" |
| #include "ElementIterator.h" |
| #include "EventHandler.h" |
| #include "EventLoop.h" |
| #include "EventNames.h" |
| #include "Frame.h" |
| #include "FrameView.h" |
| #include "HTMLAnchorElement.h" |
| #include "HTMLBodyElement.h" |
| #include "HTMLDocument.h" |
| #include "HTMLElement.h" |
| #include "HTMLImageElement.h" |
| #include "HTMLInputElement.h" |
| #include "HitTestResult.h" |
| #include "ModalContainerTypes.h" |
| #include "Page.h" |
| #include "RenderDescendantIterator.h" |
| #include "RenderText.h" |
| #include "RenderView.h" |
| #include "SimulatedClickOptions.h" |
| #include "Text.h" |
| #include <wtf/Noncopyable.h> |
| #include <wtf/RobinHoodHashSet.h> |
| #include <wtf/Scope.h> |
| #include <wtf/URL.h> |
| |
| namespace WebCore { |
| |
| static constexpr size_t maxLengthForClickableElementText = 100; |
| static constexpr double maxWidthForElementsThatLookClickable = 200; |
| static constexpr double maxHeightForElementsThatLookClickable = 100; |
| |
| bool ModalContainerObserver::isNeededFor(const Document& document) |
| { |
| RefPtr topDocumentLoader = document.topDocument().loader(); |
| if (!topDocumentLoader || topDocumentLoader->modalContainerObservationPolicy() == ModalContainerObservationPolicy::Disabled) |
| return false; |
| |
| if (!document.topDocument().url().protocolIsInHTTPFamily()) |
| return false; |
| |
| if (document.inDesignMode() || !is<HTMLDocument>(document)) |
| return false; |
| |
| auto* frame = document.frame(); |
| if (!frame) |
| return false; |
| |
| auto* page = frame->page(); |
| if (!page || page->isEditable()) |
| return false; |
| |
| if (RefPtr owner = document.ownerElement()) { |
| auto observer = owner->document().modalContainerObserverIfExists(); |
| return observer && observer->m_frameOwnersAndContainersToSearchAgain.contains(*owner); |
| } |
| |
| return true; |
| } |
| |
| ModalContainerObserver::ModalContainerObserver() |
| : m_collectClickableElementsTimer(*this, &ModalContainerObserver::collectClickableElementsTimerFired) |
| { |
| } |
| |
| ModalContainerObserver::~ModalContainerObserver() = default; |
| |
| static bool matchesSearchTerm(const Text& textNode, const AtomString& searchTerm) |
| { |
| RefPtr parent = textNode.parentElementInComposedTree(); |
| |
| static NeverDestroyed tagNamesToSearch = [] { |
| static constexpr std::array tags { |
| &HTMLNames::aTag, |
| &HTMLNames::divTag, |
| &HTMLNames::pTag, |
| &HTMLNames::spanTag, |
| &HTMLNames::sectionTag, |
| &HTMLNames::bTag, |
| &HTMLNames::iTag, |
| &HTMLNames::uTag, |
| &HTMLNames::liTag, |
| &HTMLNames::h1Tag, |
| &HTMLNames::h2Tag, |
| &HTMLNames::h3Tag, |
| &HTMLNames::h4Tag, |
| &HTMLNames::h5Tag, |
| &HTMLNames::h6Tag, |
| }; |
| MemoryCompactLookupOnlyRobinHoodHashSet<AtomString> set; |
| set.reserveInitialCapacity(std::size(tags)); |
| for (auto& tag : tags) |
| set.add(tag->get().localName()); |
| return set; |
| }(); |
| |
| if (!is<HTMLElement>(parent.get()) || !tagNamesToSearch.get().contains(downcast<HTMLElement>(*parent).localName())) |
| return false; |
| |
| if (LIKELY(!textNode.data().containsIgnoringASCIICase(searchTerm))) |
| return false; |
| |
| return true; |
| } |
| |
| static AccessibilityRole accessibilityRole(const HTMLElement& element) |
| { |
| return AccessibilityObject::ariaRoleToWebCoreRole(element.attributeWithoutSynchronization(HTMLNames::roleAttr)); |
| } |
| |
| static bool isInsideNavigationElement(const Text& textNode) |
| { |
| for (auto& parent : ancestorsOfType<HTMLElement>(textNode)) { |
| if (parent.hasTagName(HTMLNames::navTag) || accessibilityRole(parent) == AccessibilityRole::LandmarkNavigation) |
| return true; |
| } |
| return false; |
| } |
| |
| struct TextSearchResult { |
| bool foundMatch { false }; |
| bool containsAnyText { false }; |
| }; |
| |
| static TextSearchResult searchForMatch(RenderLayerModelObject& renderer, const AtomString& searchTerm) |
| { |
| TextSearchResult result; |
| for (auto& textRenderer : descendantsOfType<RenderText>(renderer)) { |
| result.containsAnyText = true; |
| if (RefPtr textNode = textRenderer.textNode(); textNode && matchesSearchTerm(*textNode, searchTerm)) { |
| result.foundMatch = !isInsideNavigationElement(*textNode); |
| return result; |
| } |
| } |
| return result; |
| } |
| |
| void ModalContainerObserver::searchForModalContainerOnBehalfOfFrameOwnerIfNeeded(HTMLFrameOwnerElement& owner) |
| { |
| auto containerToSearchAgain = m_frameOwnersAndContainersToSearchAgain.take(owner); |
| if (!containerToSearchAgain) |
| return; |
| |
| if (!m_elementsToIgnoreWhenSearching.remove(*containerToSearchAgain)) |
| return; |
| |
| if (RefPtr view = owner.document().view()) |
| updateModalContainerIfNeeded(*view); |
| } |
| |
| void ModalContainerObserver::updateModalContainerIfNeeded(const FrameView& view) |
| { |
| if (container()) |
| return; |
| |
| if (m_hasAttemptedToFulfillPolicy) |
| return; |
| |
| if (RefPtr owner = view.frame().ownerElement()) { |
| if (auto parentObserver = owner->document().modalContainerObserverIfExists()) |
| parentObserver->searchForModalContainerOnBehalfOfFrameOwnerIfNeeded(*owner); |
| return; |
| } |
| |
| if (!view.frame().isMainFrame()) |
| return; |
| |
| if (!view.hasViewportConstrainedObjects()) |
| return; |
| |
| auto searchTerm = ([&]() -> AtomString { |
| if (UNLIKELY(!m_overrideSearchTermForTesting.isNull())) |
| return m_overrideSearchTermForTesting; |
| |
| if (auto* page = view.frame().page()) |
| return page->chrome().client().searchStringForModalContainerObserver(); |
| |
| return nullAtom(); |
| })(); |
| |
| if (searchTerm.isNull()) |
| return; |
| |
| for (auto& renderer : *view.viewportConstrainedObjects()) { |
| if (renderer.isDocumentElementRenderer()) |
| continue; |
| |
| if (renderer.style().visibility() == Visibility::Hidden) |
| continue; |
| |
| RefPtr element = renderer.element(); |
| if (!element || is<HTMLBodyElement>(*element) || element->isDocumentNode()) |
| continue; |
| |
| if (m_elementsToIgnoreWhenSearching.contains(*element)) |
| continue; |
| |
| auto [foundMatch, containsAnyText] = searchForMatch(renderer, searchTerm); |
| |
| if (containsAnyText) |
| m_elementsToIgnoreWhenSearching.add(*element); |
| |
| if (foundMatch) { |
| setContainer(*element); |
| return; |
| } |
| |
| for (auto& frameOwner : descendantsOfType<HTMLFrameOwnerElement>(*element)) { |
| RefPtr contentFrame = frameOwner.contentFrame(); |
| if (!contentFrame) |
| continue; |
| |
| auto renderView = contentFrame->contentRenderer(); |
| if (!renderView) |
| continue; |
| |
| if (searchForMatch(*renderView, searchTerm).foundMatch) { |
| setContainer(*element, &frameOwner); |
| return; |
| } |
| |
| if (auto frameView = contentFrame->view(); frameView && !frameView->isVisuallyNonEmpty()) { |
| // If the subframe content has not become visually non-empty yet, search the subframe again later. |
| m_frameOwnersAndContainersToSearchAgain.add(frameOwner, *element); |
| } |
| } |
| } |
| } |
| |
| void ModalContainerObserver::setContainer(Element& newContainer, HTMLFrameOwnerElement* frameOwner) |
| { |
| if (container()) |
| container()->invalidateStyle(); |
| |
| if (m_userInteractionBlockingElement) |
| m_userInteractionBlockingElement->invalidateStyle(); |
| |
| m_userInteractionBlockingElement = { }; |
| m_containerAndFrameOwnerForControls = { { newContainer }, { frameOwner } }; |
| |
| newContainer.invalidateStyle(); |
| scheduleClickableElementCollection(); |
| |
| newContainer.document().eventLoop().queueTask(TaskSource::InternalAsyncTask, [weakContainer = WeakPtr { newContainer }]() mutable { |
| RefPtr container = weakContainer.get(); |
| if (!container) |
| return; |
| |
| auto observer = container->document().modalContainerObserverIfExists(); |
| if (!observer || container != observer->container()) |
| return; |
| |
| observer->hideUserInteractionBlockingElementIfNeeded(); |
| observer->makeBodyAndDocumentElementScrollableIfNeeded(); |
| }); |
| } |
| |
| Element* ModalContainerObserver::container() const |
| { |
| return m_containerAndFrameOwnerForControls.first.get(); |
| } |
| |
| HTMLFrameOwnerElement* ModalContainerObserver::frameOwnerForControls() const |
| { |
| return m_containerAndFrameOwnerForControls.second.get(); |
| } |
| |
| static bool listensForUserActivation(const Element& element) |
| { |
| return element.hasEventListeners(eventNames().clickEvent) || element.hasEventListeners(eventNames().mousedownEvent) || element.hasEventListeners(eventNames().mouseupEvent) |
| || element.hasEventListeners(eventNames().touchstartEvent) || element.hasEventListeners(eventNames().touchendEvent) |
| || element.hasEventListeners(eventNames().pointerdownEvent) || element.hasEventListeners(eventNames().pointerupEvent); |
| } |
| |
| enum class ContainerListensForUserActivation : bool { No, Yes }; |
| static bool isClickableControl(const HTMLElement& element, ContainerListensForUserActivation containerListensForUserActivation) |
| { |
| if (element.isActuallyDisabled()) |
| return false; |
| |
| if (!element.renderer()) |
| return false; |
| |
| if (element.hasTagName(HTMLNames::buttonTag)) |
| return true; |
| |
| if (is<HTMLInputElement>(element) && downcast<HTMLInputElement>(element).isTextButton()) |
| return true; |
| |
| switch (accessibilityRole(element)) { |
| case AccessibilityRole::Button: |
| return true; |
| case AccessibilityRole::CheckBox: |
| case AccessibilityRole::Switch: |
| return false; |
| default: |
| break; |
| } |
| |
| if (is<HTMLAnchorElement>(element)) { |
| // FIXME: We might need a more comprehensive policy here that attempts to click the link to detect navigation, |
| // but then immediately cancels the navigation. |
| auto href = downcast<HTMLAnchorElement>(element).href(); |
| return equalIgnoringFragmentIdentifier(element.document().url(), href) || !href.protocolIsInHTTPFamily(); |
| } |
| |
| if (listensForUserActivation(element)) |
| return true; |
| |
| if (containerListensForUserActivation == ContainerListensForUserActivation::No) |
| return false; |
| |
| auto rendererAndRect = element.boundingAbsoluteRectWithoutLayout(); |
| if (!rendererAndRect) |
| return false; |
| |
| auto [renderer, rect] = *rendererAndRect; |
| if (!renderer || rect.isEmpty()) |
| return false; |
| |
| // If the modal container itself has event listeners for user activation, continue looking for elements that look like |
| // clickable elements (e.g. small nodes with pointer-style cursor). |
| if (renderer->style().cursor() == CursorType::Pointer) { |
| if (rect.width() <= maxWidthForElementsThatLookClickable && rect.height() <= maxHeightForElementsThatLookClickable) |
| return true; |
| } |
| |
| return false; |
| } |
| |
| static void removeParentOrChildElements(Vector<Ref<HTMLElement>>& elements) |
| { |
| HashSet<Ref<HTMLElement>> elementsToRemove; |
| for (auto& outer : elements) { |
| if (elementsToRemove.contains(outer)) |
| continue; |
| |
| for (auto& inner : elements) { |
| if (elementsToRemove.contains(inner) || outer.ptr() == inner.ptr() || !outer->contains(inner)) |
| continue; |
| |
| if (accessibilityRole(outer) == AccessibilityRole::Button) { |
| elementsToRemove.add(inner); |
| continue; |
| } |
| |
| if (accessibilityRole(inner) == AccessibilityRole::Button) { |
| elementsToRemove.add(outer); |
| continue; |
| } |
| |
| if (outer->hasTagName(HTMLNames::divTag) || outer->hasTagName(HTMLNames::spanTag) || outer->hasTagName(HTMLNames::pTag) || outer->hasTagName(HTMLNames::sectionTag)) |
| elementsToRemove.add(outer); |
| else |
| elementsToRemove.add(inner); |
| } |
| } |
| |
| elements.removeAllMatching([&] (auto& control) { |
| return elementsToRemove.contains(control); |
| }); |
| } |
| |
| static void removeElementsWithEmptyBounds(Vector<Ref<HTMLElement>>& elements) |
| { |
| elements.removeAllMatching([&] (auto& element) { |
| return element->boundingClientRect().isEmpty(); |
| }); |
| } |
| |
| static String textForControl(HTMLElement& control) |
| { |
| auto ariaLabel = control.attributeWithoutSynchronization(HTMLNames::aria_labelAttr); |
| if (!ariaLabel.isEmpty()) |
| return ariaLabel; |
| |
| if (is<HTMLInputElement>(control)) |
| return downcast<HTMLInputElement>(control).value(); |
| |
| auto title = control.title(); |
| if (!title.isEmpty()) |
| return title; |
| |
| if (is<HTMLImageElement>(control)) { |
| auto altText = downcast<HTMLImageElement>(control).altText(); |
| if (!altText.isEmpty()) |
| return altText; |
| } |
| |
| return control.outerText(); |
| } |
| |
| void ModalContainerObserver::scheduleClickableElementCollection() |
| { |
| m_collectClickableElementsTimer.startOneShot(200_ms); |
| } |
| |
| class ModalContainerPolicyDecisionScope { |
| WTF_MAKE_NONCOPYABLE(ModalContainerPolicyDecisionScope); |
| WTF_MAKE_FAST_ALLOCATED; |
| public: |
| ModalContainerPolicyDecisionScope(Document& document) |
| : m_document { document } |
| { |
| } |
| |
| ModalContainerPolicyDecisionScope(ModalContainerPolicyDecisionScope&&) = default; |
| |
| ~ModalContainerPolicyDecisionScope() |
| { |
| if (m_continueHidingModalContainerAfterScope || !m_document) |
| return; |
| |
| if (auto observer = m_document->modalContainerObserverIfExists()) |
| observer->revealModalContainer(); |
| } |
| |
| void continueHidingModalContainerAfterScope() { m_continueHidingModalContainerAfterScope = true; } |
| Document* document() const { return m_document.get(); } |
| |
| private: |
| WeakPtr<Document> m_document; |
| bool m_continueHidingModalContainerAfterScope { false }; |
| }; |
| |
| void ModalContainerObserver::collectClickableElementsTimerFired() |
| { |
| if (!container()) |
| return; |
| |
| container()->document().eventLoop().queueTask(TaskSource::InternalAsyncTask, [observer = this, decisionScope = ModalContainerPolicyDecisionScope { container()->document() }]() mutable { |
| RefPtr document = decisionScope.document(); |
| if (!document) |
| return; |
| |
| if (observer != document->modalContainerObserverIfExists() || !observer->container()) { |
| ASSERT_NOT_REACHED(); |
| return; |
| } |
| |
| auto [classifiableControls, controlTextsToClassify] = observer->collectClickableElements(); |
| if (classifiableControls.isEmpty()) |
| return; |
| |
| auto* page = document->page(); |
| if (!page) { |
| ASSERT_NOT_REACHED(); |
| return; |
| } |
| |
| page->chrome().client().classifyModalContainerControls(WTFMove(controlTextsToClassify), [decisionScope = WTFMove(decisionScope), observer, controls = WTFMove(classifiableControls)] (auto&& types) mutable { |
| RefPtr document = decisionScope.document(); |
| if (!document) |
| return; |
| |
| RefPtr documentLoader = document->loader(); |
| if (!documentLoader) { |
| ASSERT_NOT_REACHED(); |
| return; |
| } |
| |
| if (observer != document->modalContainerObserverIfExists()) { |
| ASSERT_NOT_REACHED(); |
| return; |
| } |
| |
| if (types.size() != controls.size()) |
| return; |
| |
| struct ClassifiedControls { |
| Vector<WeakPtr<HTMLElement>> positive; |
| Vector<WeakPtr<HTMLElement>> neutral; |
| Vector<WeakPtr<HTMLElement>> negative; |
| |
| HTMLElement* controlToClick(ModalContainerDecision decision) const |
| { |
| auto matchNonNull = [&](const WeakPtr<HTMLElement>& element) { |
| return !!element; |
| }; |
| |
| switch (decision) { |
| case ModalContainerDecision::Show: |
| case ModalContainerDecision::HideAndIgnore: |
| break; |
| case ModalContainerDecision::HideAndAllow: |
| if (auto index = positive.findIf(matchNonNull); index != notFound) |
| return positive[index].get(); |
| if (auto index = neutral.findIf(matchNonNull); index != notFound) |
| return neutral[index].get(); |
| break; |
| case ModalContainerDecision::HideAndDisallow: |
| if (auto index = negative.findIf(matchNonNull); index != notFound) |
| return negative[index].get(); |
| break; |
| } |
| return nullptr; |
| } |
| |
| OptionSet<ModalContainerControlType> types() const |
| { |
| OptionSet<ModalContainerControlType> availableTypesIgnoringOther; |
| if (!positive.isEmpty()) |
| availableTypesIgnoringOther.add(ModalContainerControlType::Positive); |
| if (!negative.isEmpty()) |
| availableTypesIgnoringOther.add(ModalContainerControlType::Negative); |
| if (!neutral.isEmpty()) |
| availableTypesIgnoringOther.add(ModalContainerControlType::Neutral); |
| return availableTypesIgnoringOther; |
| } |
| }; |
| |
| ClassifiedControls classifiedControls; |
| for (size_t index = 0; index < types.size(); ++index) { |
| auto control = controls[index]; |
| if (!control) |
| continue; |
| |
| switch (types[index]) { |
| case ModalContainerControlType::Positive: |
| classifiedControls.positive.append(control); |
| break; |
| case ModalContainerControlType::Negative: |
| classifiedControls.negative.append(control); |
| break; |
| case ModalContainerControlType::Neutral: |
| classifiedControls.neutral.append(control); |
| break; |
| case ModalContainerControlType::Other: |
| break; |
| } |
| } |
| |
| observer->m_hasAttemptedToFulfillPolicy = true; |
| |
| auto* page = document->page(); |
| if (!page) |
| return; |
| |
| auto clickableControlTypes = classifiedControls.types(); |
| if (clickableControlTypes.isEmpty()) |
| return; |
| |
| page->chrome().client().decidePolicyForModalContainer(clickableControlTypes, [decisionScope = WTFMove(decisionScope), observer, classifiedControls = WTFMove(classifiedControls)](auto decision) mutable { |
| RefPtr document = decisionScope.document(); |
| if (!document) |
| return; |
| |
| if (observer != document->modalContainerObserverIfExists()) { |
| ASSERT_NOT_REACHED(); |
| return; |
| } |
| |
| if (decision == ModalContainerDecision::Show) |
| return; |
| |
| if (RefPtr controlToClick = classifiedControls.controlToClick(decision)) { |
| observer->clearScrollabilityOverrides(*document); |
| controlToClick->dispatchSimulatedClick(nullptr, SendMouseUpDownEvents, DoNotShowPressedLook); |
| } |
| |
| decisionScope.continueHidingModalContainerAfterScope(); |
| }); |
| }); |
| }); |
| } |
| |
| void ModalContainerObserver::makeBodyAndDocumentElementScrollableIfNeeded() |
| { |
| if (!container()) |
| return; |
| |
| Ref document = container()->document(); |
| RefPtr view = document->view(); |
| if (!view || view->isScrollable()) |
| return; |
| |
| document->updateLayoutIgnorePendingStylesheets(); |
| |
| auto visibleHeight = view->visibleSize().height(); |
| auto shouldMakeElementScrollable = [visibleHeight] (Element* element) { |
| if (!element) |
| return false; |
| |
| auto renderer = element->renderer(); |
| if (!renderer || renderer->style().overflowY() != Overflow::Hidden) |
| return false; |
| |
| return element->boundingClientRect().height() > visibleHeight; |
| }; |
| |
| if (!m_makeBodyElementScrollable) { |
| if (RefPtr body = document->body(); shouldMakeElementScrollable(body.get())) { |
| m_makeBodyElementScrollable = true; |
| body->invalidateStyle(); |
| } |
| } |
| |
| if (!m_makeDocumentElementScrollable) { |
| if (RefPtr documentElement = document->documentElement(); shouldMakeElementScrollable(documentElement.get())) { |
| m_makeDocumentElementScrollable = true; |
| documentElement->invalidateStyle(); |
| } |
| } |
| } |
| |
| void ModalContainerObserver::clearScrollabilityOverrides(Document& document) |
| { |
| if (std::exchange(m_makeBodyElementScrollable, false)) { |
| if (auto element = document.body()) |
| element->invalidateStyle(); |
| } |
| |
| if (std::exchange(m_makeDocumentElementScrollable, false)) { |
| if (auto element = document.documentElement()) |
| element->invalidateStyle(); |
| } |
| } |
| |
| void ModalContainerObserver::hideUserInteractionBlockingElementIfNeeded() |
| { |
| if (m_userInteractionBlockingElement) |
| return; |
| |
| RefPtr container = this->container(); |
| if (!container) { |
| ASSERT_NOT_REACHED(); |
| return; |
| } |
| |
| RefPtr view = container->document().view(); |
| if (!view) |
| return; |
| |
| auto fixedPositionRect = view->rectForFixedPositionLayout(); |
| if (fixedPositionRect.isEmpty()) |
| return; |
| |
| FixedVector locationsToHitTest { |
| fixedPositionRect.center(), |
| fixedPositionRect.minXMinYCorner() + LayoutSize { 1, 1 }, |
| fixedPositionRect.maxXMinYCorner() + LayoutSize { -1, 1 }, |
| fixedPositionRect.minXMaxYCorner() + LayoutSize { 1, -1 }, |
| fixedPositionRect.maxXMaxYCorner() + LayoutSize { -1, -1 } |
| }; |
| |
| constexpr OptionSet hitTestTypes { HitTestRequest::Type::ReadOnly, HitTestRequest::Type::DisallowUserAgentShadowContent }; |
| |
| RefPtr<Element> foundElement; |
| for (auto& location : locationsToHitTest) { |
| auto hitTestResult = view->frame().eventHandler().hitTestResultAtPoint(location, hitTestTypes); |
| auto target = hitTestResult.targetElement(); |
| if (!target || is<HTMLBodyElement>(*target) || target->isDocumentNode()) |
| return; |
| |
| if (foundElement && foundElement != target) |
| return; |
| |
| auto renderer = target->renderer(); |
| if (!renderer || renderer->firstChild() || !renderer->style().hasViewportConstrainedPosition() || renderer->isDocumentElementRenderer()) |
| return; |
| |
| if (!foundElement) |
| foundElement = target; |
| } |
| |
| m_userInteractionBlockingElement = foundElement.get(); |
| foundElement->invalidateStyle(); |
| } |
| |
| void ModalContainerObserver::revealModalContainer() |
| { |
| auto [container, frameOwner] = std::exchange(m_containerAndFrameOwnerForControls, { }); |
| if (container) { |
| container->invalidateStyle(); |
| clearScrollabilityOverrides(container->document()); |
| } |
| |
| if (auto element = std::exchange(m_userInteractionBlockingElement, { })) |
| element->invalidateStyle(); |
| } |
| |
| std::pair<Vector<WeakPtr<HTMLElement>>, Vector<String>> ModalContainerObserver::collectClickableElements() |
| { |
| Ref container = *this->container(); |
| m_collectingClickableElements = true; |
| auto exitCollectClickableElementsScope = makeScopeExit([&] { |
| m_collectingClickableElements = false; |
| container->invalidateStyle(); |
| }); |
| |
| container->invalidateStyle(); |
| container->document().updateLayoutIgnorePendingStylesheets(); |
| |
| auto containerForControls = ([&]() -> RefPtr<Element> { |
| auto frameOwner = frameOwnerForControls(); |
| if (!frameOwner) |
| return container.ptr(); |
| |
| auto contentDocument = frameOwner->contentDocument(); |
| if (!contentDocument) |
| return { }; |
| |
| return contentDocument->documentElement(); |
| })(); |
| |
| if (!containerForControls) |
| return { }; |
| |
| auto containerListensForUserActivation = listensForUserActivation(*containerForControls) ? ContainerListensForUserActivation::Yes : ContainerListensForUserActivation::No; |
| Vector<Ref<HTMLElement>> clickableControls; |
| for (auto& child : descendantsOfType<HTMLElement>(*containerForControls)) { |
| if (isClickableControl(child, containerListensForUserActivation)) |
| clickableControls.append(child); |
| } |
| |
| removeElementsWithEmptyBounds(clickableControls); |
| removeParentOrChildElements(clickableControls); |
| |
| Vector<WeakPtr<HTMLElement>> classifiableControls; |
| Vector<String> controlTextsToClassify; |
| classifiableControls.reserveInitialCapacity(clickableControls.size()); |
| controlTextsToClassify.reserveInitialCapacity(clickableControls.size()); |
| for (auto& control : clickableControls) { |
| auto text = textForControl(control).stripWhiteSpace(); |
| if (!text.isEmpty() && text.length() < maxLengthForClickableElementText) { |
| classifiableControls.uncheckedAppend({ control }); |
| controlTextsToClassify.uncheckedAppend(WTFMove(text)); |
| } |
| } |
| return { WTFMove(classifiableControls), WTFMove(controlTextsToClassify) }; |
| } |
| |
| bool ModalContainerObserver::shouldMakeVerticallyScrollable(const Element& element) const |
| { |
| if (m_makeBodyElementScrollable && element.document().body() == &element) |
| return true; |
| |
| if (m_makeDocumentElementScrollable && element.document().documentElement() == &element) |
| return true; |
| |
| return false; |
| } |
| |
| } // namespace WebCore |
