Changeset 241971 in webkit

Timestamp:

Feb 22, 2019 4:48:16 PM (5 years ago)

Author:

Wenson Hsieh

Message:

[iOS] Callout menu overlaps in-page controls when editing a comment in github.com's issue tracker
​https://bugs.webkit.org/show_bug.cgi?id=194873
<rdar://problem/46701974>

Reviewed by Tim Horton.

Source/WebKit:

On the topic of supporting web-based rich text editors on iOS, one problematic area has always been handling
conflicts between platform UI (i.e., the system callout menu) and in-page text editing controls. This issue
comes up in websites that don't use the "hidden contenteditable" approach to rich text editing, but also show
additional controls in a toolbar or contextual menu above the selection. In these cases, what often happens is
that system controls overlap controls in the page.

Luckily, the iOS callout menu (i.e. the private UICalloutBar) is capable of presenting with a list of "evasion
rects" to avoid; if the callout bar would normally intersect with one of these rects, then a different
orientation that does not intersect with one of these rects is chosen instead. Currently, the only rect added
here by UIKit when presenting the callout menu is the bounding rect of the on-screen keyboard, but after
<rdar://problem/48128337>, we now have a generalized mechanism for offering additional evasion rects before
UIKit presents the callout menu.

This patch adopts the mechanism introduced in <rdar://problem/48128337>, and introduces a heuristic for
determining the approximate location of controls in the page which might overlap the callout menu. This
heuristic works by hit-testing for clickable (but non-editable) nodes above the bounds of the selection, which
are additionally not hit-tested by advancing outwards from any of the other edges of the selection bounds.
Additionally, any hit-tested nodes whose bounding rects are very large (relative to the content view size) are
ignored (this deals with scenarios where the body or a large container element has a click handler). We then add
the bounding rects of each of the nodes that fit this criteria to the list of rects for UIKit to avoid when
presenting the system callout menu.

The result is that WebKit will, by default, avoid overlapping anything that looks like controls in the page when
showing a callout menu in editable content. In practice, this fixes overlapping controls on most websites that
roll their own context menu or toolbar in their rich text editor.

Test: editing/selection/ios/avoid-showing-callout-menu-over-controls.html

• Platform/spi/ios/UIKitSPI.h:
• UIProcess/WebPageProxy.h:
• UIProcess/ios/WKContentViewInteraction.mm:

(-[WKContentView requestAutocorrectionRectsForString:withCompletionHandler:]):
(-[WKContentView requestRectsToEvadeForSelectionCommandsWithCompletionHandler:]):
(-[WKContentView requestAutocorrectionContextWithCompletionHandler:]):

Drive-by: handle null completion handler arguments more gracefully, by raising an NSException and bailing before
attempting to invoke a nil block.

• UIProcess/ios/WebPageProxyIOS.mm:

(WebKit::WebPageProxy::requestEvasionRectsAboveSelection):

See above for more detail.

• WebProcess/WebPage/WebPage.h:
• WebProcess/WebPage/WebPage.messages.in:
• WebProcess/WebPage/ios/WebPageIOS.mm:

(WebKit::WebPage::requestEvasionRectsAboveSelection):

Tools:

Add a couple of UIScriptController methods to make callout menu testing on iOS easier (see below).

• DumpRenderTree/ios/UIScriptControllerIOS.mm:

(WTR::UIScriptController::menuRect const):
(WTR::UIScriptController::isShowingMenu const):

• TestRunnerShared/UIScriptContext/Bindings/UIScriptController.idl:
• TestRunnerShared/UIScriptContext/UIScriptController.cpp:

(WTR::UIScriptController::menuRect const):

Add a function to query the bounds of the callout menu in content coordinates.

(WTR::UIScriptController::isShowingMenu const):

Add a function to query whether the callout menu is shown (i.e., has finished its appearance animation).

• TestRunnerShared/UIScriptContext/UIScriptController.h:
• WebKitTestRunner/cocoa/TestRunnerWKWebView.h:
• WebKitTestRunner/ios/UIScriptControllerIOS.mm:

(WTR::UIScriptController::rectForMenuAction const):
(WTR::UIScriptController::menuRect const):
(WTR::UIScriptController::isShowingMenu const):
(WTR::findViewInHierarchyOfType): Deleted.

LayoutTests:

Add a test to ensure that the we dodge clickable elements when showing the callout bar.

• editing/selection/ios/avoid-showing-callout-menu-over-controls-expected.txt: Added.
• editing/selection/ios/avoid-showing-callout-menu-over-controls.html: Added.
• resources/ui-helper.js:

(window.UIHelper.waitForMenuToShow.return.new.Promise):
(window.UIHelper.waitForMenuToShow):
(window.UIHelper.menuRect):
(window.UIHelper):

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/editing/selection/ios/avoid-showing-callout-menu-over-controls-expected.txt (added)
• LayoutTests/editing/selection/ios/avoid-showing-callout-menu-over-controls.html (added)
• LayoutTests/resources/ui-helper.js (modified) (1 diff)
• Source/WebKit/ChangeLog (modified) (1 diff)
• Source/WebKit/Platform/spi/ios/UIKitSPI.h (modified) (1 diff)
• Source/WebKit/UIProcess/WebPageProxy.h (modified) (1 diff)
• Source/WebKit/UIProcess/ios/WKContentViewInteraction.mm (modified) (3 diffs)
• Source/WebKit/UIProcess/ios/WebPageProxyIOS.mm (modified) (2 diffs)
• Source/WebKit/WebProcess/WebPage/WebPage.h (modified) (1 diff)
• Source/WebKit/WebProcess/WebPage/WebPage.messages.in (modified) (1 diff)
• Source/WebKit/WebProcess/WebPage/ios/WebPageIOS.mm (modified) (1 diff)
• Tools/ChangeLog (modified) (1 diff)
• Tools/DumpRenderTree/ios/UIScriptControllerIOS.mm (modified) (1 diff)
• Tools/TestRunnerShared/UIScriptContext/Bindings/UIScriptController.idl (modified) (1 diff)
• Tools/TestRunnerShared/UIScriptContext/UIScriptController.cpp (modified) (1 diff)
• Tools/TestRunnerShared/UIScriptContext/UIScriptController.h (modified) (1 diff)
• Tools/WebKitTestRunner/cocoa/TestRunnerWKWebView.h (modified) (1 diff)
• Tools/WebKitTestRunner/ios/UIScriptControllerIOS.mm (modified) (3 diffs)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2019-02-22  Wenson Hsieh  <wenson_hsieh@apple.com>
+
+        [iOS] Callout menu overlaps in-page controls when editing a comment in github.com's issue tracker
+        https://bugs.webkit.org/show_bug.cgi?id=194873
+        <rdar://problem/46701974>
+
+        Reviewed by Tim Horton.
+
+        Add a test to ensure that the we dodge clickable elements when showing the callout bar.
+
+        * editing/selection/ios/avoid-showing-callout-menu-over-controls-expected.txt: Added.
+        * editing/selection/ios/avoid-showing-callout-menu-over-controls.html: Added.
+        * resources/ui-helper.js:
+        (window.UIHelper.waitForMenuToShow.return.new.Promise):
+        (window.UIHelper.waitForMenuToShow):
+        (window.UIHelper.menuRect):
+        (window.UIHelper):
+
 2019-02-22  Wenson Hsieh  <wenson_hsieh@apple.com>
 

trunk/LayoutTests/resources/ui-helper.js

@@ -666 +666 @@
         return new Promise(resolve => testRunner.runUIScript(script, result => resolve(JSON.parse(result))));
     }
+
+    static waitForMenuToShow()
+    {
+        return new Promise(resolve => {
+            testRunner.runUIScript(`
+                (function() {
+                    if (!uiController.isShowingMenu)
+                        uiController.didShowMenuCallback = () => uiController.uiScriptComplete();
+                    else
+                        uiController.uiScriptComplete();
+                })()`, resolve);
+        });
+    }
+
+    static menuRect()
+    {
+        return new Promise(resolve => {
+            testRunner.runUIScript("JSON.stringify(uiController.menuRect)", result => resolve(JSON.parse(result)));
+        });
+    }
 }

trunk/Source/WebKit/ChangeLog

@@ +1 @@
+2019-02-22  Wenson Hsieh  <wenson_hsieh@apple.com>
+
+        [iOS] Callout menu overlaps in-page controls when editing a comment in github.com's issue tracker
+        https://bugs.webkit.org/show_bug.cgi?id=194873
+        <rdar://problem/46701974>
+
+        Reviewed by Tim Horton.
+
+        On the topic of supporting web-based rich text editors on iOS, one problematic area has always been handling
+        conflicts between platform UI (i.e., the system callout menu) and in-page text editing controls. This issue
+        comes up in websites that don't use the "hidden contenteditable" approach to rich text editing, but also show
+        additional controls in a toolbar or contextual menu above the selection. In these cases, what often happens is
+        that system controls overlap controls in the page.
+
+        Luckily, the iOS callout menu (i.e. the private UICalloutBar) is capable of presenting with a list of "evasion
+        rects" to avoid; if the callout bar would normally intersect with one of these rects, then a different
+        orientation that does not intersect with one of these rects is chosen instead. Currently, the only rect added
+        here by UIKit when presenting the callout menu is the bounding rect of the on-screen keyboard, but after
+        <rdar://problem/48128337>, we now have a generalized mechanism for offering additional evasion rects before
+        UIKit presents the callout menu.
+
+        This patch adopts the mechanism introduced in <rdar://problem/48128337>, and introduces a heuristic for
+        determining the approximate location of controls in the page which might overlap the callout menu. This
+        heuristic works by hit-testing for clickable (but non-editable) nodes above the bounds of the selection, which
+        are additionally not hit-tested by advancing outwards from any of the other edges of the selection bounds.
+        Additionally, any hit-tested nodes whose bounding rects are very large (relative to the content view size) are
+        ignored (this deals with scenarios where the body or a large container element has a click handler). We then add
+        the bounding rects of each of the nodes that fit this criteria to the list of rects for UIKit to avoid when
+        presenting the system callout menu.
+
+        The result is that WebKit will, by default, avoid overlapping anything that looks like controls in the page when
+        showing a callout menu in editable content. In practice, this fixes overlapping controls on most websites that
+        roll their own context menu or toolbar in their rich text editor.
+
+        Test: editing/selection/ios/avoid-showing-callout-menu-over-controls.html
+
+        * Platform/spi/ios/UIKitSPI.h:
+        * UIProcess/WebPageProxy.h:
+        * UIProcess/ios/WKContentViewInteraction.mm:
+        (-[WKContentView requestAutocorrectionRectsForString:withCompletionHandler:]):
+        (-[WKContentView requestRectsToEvadeForSelectionCommandsWithCompletionHandler:]):
+        (-[WKContentView requestAutocorrectionContextWithCompletionHandler:]):
+
+        Drive-by: handle null completion handler arguments more gracefully, by raising an NSException and bailing before
+        attempting to invoke a nil block.
+
+        * UIProcess/ios/WebPageProxyIOS.mm:
+        (WebKit::WebPageProxy::requestEvasionRectsAboveSelection):
+
+        See above for more detail.
+
+        * WebProcess/WebPage/WebPage.h:
+        * WebProcess/WebPage/WebPage.messages.in:
+        * WebProcess/WebPage/ios/WebPageIOS.mm:
+        (WebKit::WebPage::requestEvasionRectsAboveSelection):
+
 2019-02-22  Simon Fraser  <simon.fraser@apple.com>
 

trunk/Source/WebKit/Platform/spi/ios/UIKitSPI.h

@@ -989 +989 @@
 
 @interface UICalloutBar : UIView
++ (UICalloutBar *)activeCalloutBar;
 + (void)fadeSharedCalloutBar;
 @end

trunk/Source/WebKit/UIProcess/WebPageProxy.h

@@ -688 +688 @@
     void hardwareKeyboardAvailabilityChanged();
     bool isScrollingOrZooming() const { return m_isScrollingOrZooming; }
+    void requestEvasionRectsAboveSelection(CompletionHandler<void(const Vector<WebCore::FloatRect>&)>&&);
 #if ENABLE(DATA_INTERACTION)
     void didHandleDragStartRequest(bool started);

trunk/Source/WebKit/UIProcess/ios/WKContentViewInteraction.mm

@@ -3354 +3354 @@
 - (void)requestAutocorrectionRectsForString:(NSString *)input withCompletionHandler:(void (^)(UIWKAutocorrectionRects *rectsForInput))completionHandler
 {
+    if (!completionHandler) {
+        [NSException raise:NSInvalidArgumentException format:@"Expected a nonnull completion handler in %s.", __PRETTY_FUNCTION__];
+        return;
+    }
+
     if (!input || ![input length]) {
-        if (completionHandler)
-            completionHandler(nil);
+        completionHandler(nil);
         return;
     }
@@ -3374 +3378 @@
         view->_autocorrectionData.textLastRect = lastRect;
 
-        if (completion)
-            completion(rects.size() ? [WKAutocorrectionRects autocorrectionRectsWithRects:firstRect lastRect:lastRect] : nil);
+        completion(rects.size() ? [WKAutocorrectionRects autocorrectionRectsWithRects:firstRect lastRect:lastRect] : nil);
+    });
+}
+
+- (void)requestRectsToEvadeForSelectionCommandsWithCompletionHandler:(void(^)(NSArray<NSValue *> *rects))completionHandler
+{
+    if (!completionHandler) {
+        [NSException raise:NSInvalidArgumentException format:@"Expected a nonnull completion handler in %s.", __PRETTY_FUNCTION__];
+        return;
+    }
+
+    if ([self _shouldSuppressSelectionCommands] || _webView._editable) {
+        completionHandler(@[ ]);
+        return;
+    }
+
+    if (_focusedElementInformation.elementType != WebKit::InputType::ContentEditable && _focusedElementInformation.elementType != WebKit::InputType::TextArea) {
+        completionHandler(@[ ]);
+        return;
+    }
+
+    // Give the page some time to present custom editing UI before attempting to detect and evade it.
+    auto delayBeforeShowingCalloutBar = (0.25_s).nanoseconds();
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, delayBeforeShowingCalloutBar), dispatch_get_main_queue(), [completion = makeBlockPtr(completionHandler), weakSelf = WeakObjCPtr<WKContentView>(self)] () mutable {
+        if (!weakSelf) {
+            completion(@[ ]);
+            return;
+        }
+
+        auto strongSelf = weakSelf.get();
+        if (!strongSelf->_page) {
+            completion(@[ ]);
+            return;
+        }
+
+        strongSelf->_page->requestEvasionRectsAboveSelection([completion = WTFMove(completion)] (auto& rects) {
+            auto rectsAsValues = adoptNS([[NSMutableArray alloc] initWithCapacity:rects.size()]);
+            for (auto& floatRect : rects)
+                [rectsAsValues addObject:[NSValue valueWithCGRect:floatRect]];
+            completion(rectsAsValues.get());
+        });
     });
 }
@@ -3538 +3581 @@
 - (void)requestAutocorrectionContextWithCompletionHandler:(void (^)(UIWKAutocorrectionContext *autocorrectionContext))completionHandler
 {
-    if (!completionHandler)
-        return;
+    if (!completionHandler) {
+        [NSException raise:NSInvalidArgumentException format:@"Expected a nonnull completion handler in %s.", __PRETTY_FUNCTION__];
+        return;
+    }
 
 #if USE(UIKIT_KEYBOARD_ADDITIONS)

trunk/Source/WebKit/UIProcess/ios/WebPageProxyIOS.mm

@@ -30 +30 @@
 
 #import "APIUIClient.h"
+#import "Connection.h"
 #import "DataReference.h"
 #import "EditingRange.h"
@@ -1113 +1114 @@
 }
 
+void WebPageProxy::requestEvasionRectsAboveSelection(CompletionHandler<void(const Vector<WebCore::FloatRect>&)>&& callback)
+{
+    if (!isValid()) {
+        callback({ });
+        return;
+    }
+
+    m_process->connection()->sendWithAsyncReply(Messages::WebPage::RequestEvasionRectsAboveSelection(), WTFMove(callback), m_pageID);
+}
+
 #if ENABLE(DATA_INTERACTION)
 

trunk/Source/WebKit/WebProcess/WebPage/WebPage.h

@@ -665 +665 @@
     void startAutoscrollAtPosition(const WebCore::FloatPoint&);
     void cancelAutoscroll();
+    void requestEvasionRectsAboveSelection(CompletionHandler<void(const Vector<WebCore::FloatRect>&)>&&);
 
     void contentSizeCategoryDidChange(const String&);

trunk/Source/WebKit/WebProcess/WebPage/WebPage.messages.in

@@ -81 +81 @@
     RequestAutocorrectionContext(WebKit::CallbackID callbackID)
     AutocorrectionContextSync() -> (struct WebKit::WebAutocorrectionContext context) Delayed
+    RequestEvasionRectsAboveSelection() -> (Vector<WebCore::FloatRect> rects) Async
     GetPositionInformation(struct WebKit::InteractionInformationRequest request) -> (struct WebKit::InteractionInformationAtPosition information) Delayed
     RequestPositionInformation(struct WebKit::InteractionInformationRequest request)

trunk/Source/WebKit/WebProcess/WebPage/ios/WebPageIOS.mm

@@ -1505 +1505 @@
 }
 
+void WebPage::requestEvasionRectsAboveSelection(CompletionHandler<void(const Vector<FloatRect>&)>&& reply)
+{
+    auto& frame = m_page->focusController().focusedOrMainFrame();
+    auto frameView = makeRefPtr(frame.view());
+    if (!frameView) {
+        reply({ });
+        return;
+    }
+
+    auto& selection = frame.selection().selection();
+    if (selection.isNone()) {
+        reply({ });
+        return;
+    }
+
+    auto selectedRange = selection.toNormalizedRange();
+    if (!selectedRange) {
+        reply({ });
+        return;
+    }
+
+    if (!m_focusedElement || !m_focusedElement->renderer() || m_focusedElement->renderer()->isTransparentOrFullyClippedRespectingParentFrames()) {
+        reply({ });
+        return;
+    }
+
+    float scaleFactor = pageScaleFactor();
+    const double factorOfContentArea = 0.5;
+    auto unobscuredContentArea = m_page->mainFrame().view()->unobscuredContentRect().area();
+    if (unobscuredContentArea.hasOverflowed()) {
+        reply({ });
+        return;
+    }
+
+    double contextMenuAreaLimit = factorOfContentArea * scaleFactor * unobscuredContentArea.unsafeGet();
+
+    FloatRect selectionBoundsInRootViewCoordinates;
+    if (selection.isRange())
+        selectionBoundsInRootViewCoordinates = frameView->contentsToRootView(selectedRange->absoluteBoundingBox());
+    else
+        selectionBoundsInRootViewCoordinates = frameView->contentsToRootView(frame.selection().absoluteCaretBounds());
+
+    auto centerOfTargetBounds = selectionBoundsInRootViewCoordinates.center();
+    FloatPoint centerTopInRootViewCoordinates { centerOfTargetBounds.x(), selectionBoundsInRootViewCoordinates.y() };
+
+    auto clickableNonEditableNode = [&] (const FloatPoint& locationInRootViewCoordinates) -> Node* {
+        FloatPoint adjustedPoint;
+        auto* hitNode = m_page->mainFrame().nodeRespondingToClickEvents(locationInRootViewCoordinates, adjustedPoint);
+        if (!hitNode || is<HTMLBodyElement>(hitNode) || is<Document>(hitNode) || hitNode->hasEditableStyle())
+            return nullptr;
+
+        return hitNode;
+    };
+
+    // This heuristic attempts to find a list of rects to avoid when showing the callout menu on iOS.
+    // First, hit-test several points above the bounds of the selection rect in search of clickable nodes that are not editable.
+    // Secondly, hit-test several points around the edges of the selection rect and exclude any nodes found in the first round of
+    // hit-testing if these nodes are also reachable by moving outwards from the left, right, or bottom edges of the selection.
+    // Additionally, exclude any hit-tested nodes that are either very large relative to the size of the root view, or completely
+    // encompass the selection bounds. The resulting rects are the bounds of these hit-tested nodes in root view coordinates.
+    HashSet<Ref<Node>> hitTestedNodes;
+    Vector<FloatRect> rectsToAvoidInRootViewCoordinates;
+    const Vector<FloatPoint, 5> offsetsForHitTesting {{ -30, -50 }, { 30, -50 }, { -60, -35 }, { 60, -35 }, { 0, -20 }};
+    for (auto offset : offsetsForHitTesting) {
+        offset.scale(1 / scaleFactor);
+        if (auto* hitNode = clickableNonEditableNode(centerTopInRootViewCoordinates + offset))
+            hitTestedNodes.add(*hitNode);
+    }
+
+    const float marginForHitTestingSurroundingNodes = 80 / scaleFactor;
+    Vector<FloatPoint, 3> exclusionHitTestLocations {
+        { selectionBoundsInRootViewCoordinates.x() - marginForHitTestingSurroundingNodes, centerOfTargetBounds.y() },
+        { centerOfTargetBounds.x(), selectionBoundsInRootViewCoordinates.maxY() + marginForHitTestingSurroundingNodes },
+        { selectionBoundsInRootViewCoordinates.maxX() + marginForHitTestingSurroundingNodes, centerOfTargetBounds.y() }
+    };
+
+    for (auto& location : exclusionHitTestLocations) {
+        if (auto* nodeToExclude = clickableNonEditableNode(location))
+            hitTestedNodes.remove(*nodeToExclude);
+    }
+
+    for (auto& node : hitTestedNodes) {
+        auto frameView = makeRefPtr(node->document().view());
+        auto* renderer = node->renderer();
+        if (!renderer || !frameView)
+            continue;
+
+        auto bounds = frameView->contentsToRootView(renderer->absoluteBoundingBoxRect());
+        auto area = bounds.area();
+        if (area.hasOverflowed() || area.unsafeGet() > contextMenuAreaLimit)
+            continue;
+
+        if (bounds.contains(enclosingIntRect(selectionBoundsInRootViewCoordinates)))
+            continue;
+
+        rectsToAvoidInRootViewCoordinates.append(WTFMove(bounds));
+    }
+
+    reply(WTFMove(rectsToAvoidInRootViewCoordinates));
+}
+
 void WebPage::getRectsForGranularityWithSelectionOffset(uint32_t granularity, int32_t offset, CallbackID callbackID)
 {

trunk/Tools/ChangeLog

@@ +1 @@
+2019-02-22  Wenson Hsieh  <wenson_hsieh@apple.com>
+
+        [iOS] Callout menu overlaps in-page controls when editing a comment in github.com's issue tracker
+        https://bugs.webkit.org/show_bug.cgi?id=194873
+        <rdar://problem/46701974>
+
+        Reviewed by Tim Horton.
+
+        Add a couple of UIScriptController methods to make callout menu testing on iOS easier (see below).
+
+        * DumpRenderTree/ios/UIScriptControllerIOS.mm:
+        (WTR::UIScriptController::menuRect const):
+        (WTR::UIScriptController::isShowingMenu const):
+        * TestRunnerShared/UIScriptContext/Bindings/UIScriptController.idl:
+        * TestRunnerShared/UIScriptContext/UIScriptController.cpp:
+        (WTR::UIScriptController::menuRect const):
+
+        Add a function to query the bounds of the callout menu in content coordinates.
+
+        (WTR::UIScriptController::isShowingMenu const):
+
+        Add a function to query whether the callout menu is shown (i.e., has finished its appearance animation).
+
+        * TestRunnerShared/UIScriptContext/UIScriptController.h:
+        * WebKitTestRunner/cocoa/TestRunnerWKWebView.h:
+        * WebKitTestRunner/ios/UIScriptControllerIOS.mm:
+        (WTR::UIScriptController::rectForMenuAction const):
+        (WTR::UIScriptController::menuRect const):
+        (WTR::UIScriptController::isShowingMenu const):
+        (WTR::findViewInHierarchyOfType): Deleted.
+
 2019-02-22  Chris Dumez  <cdumez@apple.com>
 

trunk/Tools/DumpRenderTree/ios/UIScriptControllerIOS.mm

@@ -338 +338 @@
 }
 
+JSObjectRef UIScriptController::menuRect() const
+{
+    return nullptr;
+}
+
+bool UIScriptController::isShowingMenu() const
+{
+    return false;
+}
+
 void UIScriptController::platformSetDidEndScrollingCallback()
 {

trunk/Tools/TestRunnerShared/UIScriptContext/Bindings/UIScriptController.idl

@@ -226 +226 @@
     attribute object didShowMenuCallback;
     attribute object didHideMenuCallback;
+    readonly attribute boolean isShowingMenu;
+    readonly attribute object menuRect;
     object rectForMenuAction(DOMString action);
 

trunk/Tools/TestRunnerShared/UIScriptContext/UIScriptController.cpp

@@ -533 +533 @@
 }
 
+JSObjectRef UIScriptController::menuRect() const
+{
+    return nullptr;
+}
+
 JSObjectRef UIScriptController::rectForMenuAction(JSStringRef) const
 {
     return nullptr;
+}
+
+bool UIScriptController::isShowingMenu() const
+{
+    return false;
 }
 

trunk/Tools/TestRunnerShared/UIScriptContext/UIScriptController.h

@@ -165 +165 @@
     JSValueRef didShowMenuCallback() const;
 
+    bool isShowingMenu() const;
     JSObjectRef rectForMenuAction(JSStringRef action) const;
+    JSObjectRef menuRect() const;
 
     void setDidEndScrollingCallback(JSValueRef);

trunk/Tools/WebKitTestRunner/cocoa/TestRunnerWKWebView.h

@@ -57 +57 @@
 
 @property (nonatomic, readonly, getter=isShowingKeyboard) BOOL showingKeyboard;
+@property (nonatomic, readonly, getter=isShowingMenu) BOOL showingMenu;
 @property (nonatomic, assign) BOOL usesSafariLikeRotation;
 @property (nonatomic, readonly, getter=isInteractingWithFormControl) BOOL interactingWithFormControl;

trunk/Tools/WebKitTestRunner/ios/UIScriptControllerIOS.mm

@@ -118 +118 @@
 }
 
-static UIView *findViewInHierarchyOfType(UIView *view, Class viewClass)
-{
-    __block RetainPtr<UIView> foundView;
-    forEachViewInHierarchy(view, ^(UIView *subview, BOOL *stop) {
-        if (![subview isKindOfClass:viewClass])
-            return;
-
-        foundView = subview;
-        *stop = YES;
-    });
-    return foundView.autorelease();
-}
-
 static NSArray<UIView *> *findAllViewsInHierarchyOfType(UIView *view, Class viewClass)
 {
@@ -884 +871 @@
     UIWindow *windowForButton = nil;
     UIButton *buttonForAction = nil;
-    for (UIWindow *window in UIApplication.sharedApplication.windows) {
-        if (![window isKindOfClass:UITextEffectsWindow.class])
+    UIView *calloutBar = UICalloutBar.activeCalloutBar;
+    if (!calloutBar.window)
+        return nullptr;
+
+    for (UIButton *button in findAllViewsInHierarchyOfType(calloutBar, UIButton.class)) {
+        NSString *buttonTitle = [button titleForState:UIControlStateNormal];
+        if (!buttonTitle.length)
             continue;
 
-        UIView *calloutBar = findViewInHierarchyOfType(window, UICalloutBar.class);
-        if (!calloutBar)
+        if (![buttonTitle isEqualToString:(__bridge NSString *)action.get()])
             continue;
 
-        for (UIButton *button in findAllViewsInHierarchyOfType(calloutBar, UIButton.class)) {
-            NSString *buttonTitle = [button titleForState:UIControlStateNormal];
-            if (!buttonTitle.length)
-                continue;
-
-            if (![buttonTitle isEqualToString:(__bridge NSString *)action.get()])
-                continue;
-
-            buttonForAction = button;
-            windowForButton = window;
-        }
+        buttonForAction = button;
+        windowForButton = calloutBar.window;
+        break;
     }
 
@@ -910 +893 @@
     CGRect rectInRootViewCoordinates = [buttonForAction convertRect:buttonForAction.bounds toView:platformContentView()];
     return m_context->objectFromRect(WebCore::FloatRect(rectInRootViewCoordinates.origin.x, rectInRootViewCoordinates.origin.y, rectInRootViewCoordinates.size.width, rectInRootViewCoordinates.size.height));
+}
+
+JSObjectRef UIScriptController::menuRect() const
+{
+    UIView *calloutBar = UICalloutBar.activeCalloutBar;
+    if (!calloutBar.window)
+        return nullptr;
+
+    CGRect rectInRootViewCoordinates = [calloutBar convertRect:calloutBar.bounds toView:platformContentView()];
+    return m_context->objectFromRect(WebCore::FloatRect(rectInRootViewCoordinates.origin.x, rectInRootViewCoordinates.origin.y, rectInRootViewCoordinates.size.width, rectInRootViewCoordinates.size.height));
+}
+
+bool UIScriptController::isShowingMenu() const
+{
+    return TestController::singleton().mainWebView()->platformView().showingMenu;
 }