[iOS] Do not show selection UI for editable elements with opacity near zero
authorwenson_hsieh@apple.com <wenson_hsieh@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 13 Nov 2018 22:30:27 +0000 (22:30 +0000)
committerwenson_hsieh@apple.com <wenson_hsieh@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 13 Nov 2018 22:30:27 +0000 (22:30 +0000)
commit42041c7ff0e543d723c2433b79102e4fe4c22fae
tree26d4534b22377a986ffe3603f4ec70f4dcd301b1
parentcedb1e5eb70669834e57ec480f72db816ed36cb3
[iOS] Do not show selection UI for editable elements with opacity near zero
https://bugs.webkit.org/show_bug.cgi?id=191442
<rdar://problem/45958625>

Reviewed by Simon Fraser.

Source/WebCore:

Tests: editing/selection/ios/do-not-zoom-to-focused-hidden-contenteditable.html
       editing/selection/ios/hide-selection-after-hiding-contenteditable.html
       editing/selection/ios/hide-selection-in-contenteditable-nested-transparency.html
       editing/selection/ios/hide-selection-in-hidden-contenteditable-frame.html
       editing/selection/ios/hide-selection-in-hidden-contenteditable.html

* rendering/RenderObject.cpp:
(WebCore::RenderObject::isTransparentRespectingParentFrames const):

Add a helper function to determine whether a RenderObject is contained within a transparent layer, taking parent
frames into account. A layer is considered transparent if its opacity is less than a small threshold (i.e. 0.01).
Opacity on ancestor elements is applied multiplicatively.

* rendering/RenderObject.h:

Source/WebKit:

Add support for suppressing native selection UI (for instance, selection highlight views, selection handles, and
selection-related gestures) when the selection is inside a transparent editable element. This helps maintain
compatibility with text editors that work by capturing key events and input events hidden contenteditable
elements, and reflect these changes in different document or different part of the document.

Since selection UI is rendered in the UI process on iOS using element geometry propagated from the web process,
selection rendering is entirely decoupled from the process of painting in the web process. This means that if
the editable root has an opacity of 0, we would correctly hide the caret and selection on macOS, but draw over
the transparent element on iOS. When these hidden editable elements are focused, this often results in unwanted
behaviors, such as double caret painting, native and custom selection UI from the page being drawn on top of one
another, and the ability to change selection via tap and loupe gestures within hidden text.

To fix this, we compute whether the focused element is transparent when an element is focused, or when the
selection changes, and send this information over to the UI process via `AssistedNodeInformation` and
`EditorState`. In the UI process, we then respect this information by suppressing the selection assistant if the
focused element is transparent; this disables showing and laying out selection views, as well as gestures
associated with selection overlays. However, this still allows for contextual autocorrection and spell checking.

* Shared/AssistedNodeInformation.cpp:
(WebKit::AssistedNodeInformation::encode const):
(WebKit::AssistedNodeInformation::decode):
* Shared/AssistedNodeInformation.h:
* Shared/EditorState.cpp:
(WebKit::EditorState::PostLayoutData::encode const):
(WebKit::EditorState::PostLayoutData::decode):
* Shared/EditorState.h:

Add `elementIsTransparent` flags, and also add boilerplate IPC code.

* UIProcess/ios/WKContentViewInteraction.mm:
(-[WKContentView _displayFormNodeInputView]):

Prevent zooming to the focused element if the focused element is hidden.

(-[WKContentView hasSelectablePositionAtPoint:]):
(-[WKContentView pointIsNearMarkedText:]):
(-[WKContentView textInteractionGesture:shouldBeginAtPoint:]):

Don't allow these text interaction gestures to begin while suppressing the selection assistant.

(-[WKContentView _startAssistingNode:userIsInteracting:blurPreviousNode:changingActivityState:userObject:]):

When an element is focused, begin suppressing the selection assistant if the element is fully transparent.

(-[WKContentView _stopAssistingNode]):

When the focused element is blurred, reset state by ending selection assistant suppression (additionally
reactivating the selection assistant if needed). This ensures that selection in non-editable text isn't broken
after focusing a hidden editable element.

(-[WKContentView _updateChangedSelection:]):

If needed, suppress or un-suppress the selection assistant when the selection changes. On certain rich text
editors, a combination of custom selection UI and native selection UI is used. For instance, on Microsoft Office
365, caret selections are rendered using the native caret view, but as soon as the selection becomes ranged, the
editable root becomes fully transparent, and Office's selection UI takes over.

(-[WKContentView _shouldSuppressSelectionCommands]):

Override this UIKit SPI hook to suppress selection commands (e.g. the callout bar) when suppressing the
selection assistant.

* WebProcess/WebPage/ios/WebPageIOS.mm:
(WebKit::WebPage::platformEditorState const):
(WebKit::WebPage::getAssistedNodeInformation):

Compute and set `elementIsTransparent` using the assisted node.

Tools:

Add a couple of new testing helpers to UIScriptController.

* TestRunnerShared/UIScriptContext/Bindings/UIScriptController.idl:
* TestRunnerShared/UIScriptContext/UIScriptController.cpp:
(WTR::UIScriptController::textSelectionRangeRects const):
(WTR::UIScriptController::selectionCaretViewRect const):
(WTR::UIScriptController::selectionRangeViewRects const):
* TestRunnerShared/UIScriptContext/UIScriptController.h:
* WebKitTestRunner/ios/UIScriptControllerIOS.mm:
(WTR::UIScriptController::textSelectionRangeRects const):

Rename `selectionRangeViewRects` to `textSelectionRangeRects`. This allows us to draw a distinction between
`textSelectionRangeRects`/`textSelectionCaretRect`, which retrieve information about selection rects known
to the text interaction assistant, and `selectionCaretViewRect`/`selectionRangeViewRects`, which retrieve the
actual frames of the selection views used to draw overlaid selection UI. This difference is important in the
new layout tests added in this patch, which only suppress caret rendering (i.e. selection views remain hidden).

Also, drive-by fix a leaked `NSMutableArray`.

(WTR::UIScriptController::selectionStartGrabberViewRect const):
(WTR::UIScriptController::selectionEndGrabberViewRect const):
(WTR::UIScriptController::selectionCaretViewRect const):
(WTR::UIScriptController::selectionRangeViewRects const):

Testing helpers to grab the frames of caret and selection views, in WKContentView's coordinate space. These
rects are also clamped to WKContentView bounds.

LayoutTests:

Add 5 new layout tests. See below for more details.

* editing/selection/character-granularity-rect.html:

Adjust for a renamed UIScriptController function.

* editing/selection/ios/do-not-zoom-to-focused-hidden-contenteditable-expected.txt: Added.
* editing/selection/ios/do-not-zoom-to-focused-hidden-contenteditable.html: Added.

Add a test to verify that we don't zoom to fit the focused element, if the focused element is completely
transparent.

* editing/selection/ios/hide-selection-after-hiding-contenteditable-expected.txt: Added.
* editing/selection/ios/hide-selection-after-hiding-contenteditable.html: Added.

Add a test to verify that selection UI is hidden after making an editable root transparent, and shown again when
the editable root becomes opaque.

* editing/selection/ios/hide-selection-in-contenteditable-nested-transparency-expected.txt: Added.
* editing/selection/ios/hide-selection-in-contenteditable-nested-transparency.html: Added.

Add a test to verify that transparency applied on an editable root via nested transparent containers causes
selection UI to be suppressed.

* editing/selection/ios/hide-selection-in-hidden-contenteditable-expected.txt: Added.
* editing/selection/ios/hide-selection-in-hidden-contenteditable-frame-expected.txt: Added.
* editing/selection/ios/hide-selection-in-hidden-contenteditable-frame.html: Added.

Add a test to verify that selection UI is suppressed when an editable element inside a subframe is focused. This
test checks that the caret, selection rects and selection handle views are not shown, and additionally verifies
that the selection in a hidden contenteditable area cannot be changed via tap gesture.

* editing/selection/ios/hide-selection-in-hidden-contenteditable.html: Added.

Same test as above, but in a regular editable element in the main document instead of a subframe.

* resources/ui-helper.js:
(window.UIHelper.getUISelectionRects.return.new.Promise.):
(window.UIHelper.getUISelectionRects.return.new.Promise):
(window.UIHelper.getUISelectionRects):
(window.UIHelper.getUICaretViewRect.return.new.Promise.):
(window.UIHelper.getUICaretViewRect.return.new.Promise):
(window.UIHelper.getUICaretViewRect):

Add new UIHelper wrapper methods. See Tools/ChangeLog for more detail.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@238146 268f45cc-cd09-0410-ab3c-d52691b4dbfc
29 files changed:
LayoutTests/ChangeLog
LayoutTests/editing/selection/character-granularity-rect.html
LayoutTests/editing/selection/ios/do-not-zoom-to-focused-hidden-contenteditable-expected.txt [new file with mode: 0644]
LayoutTests/editing/selection/ios/do-not-zoom-to-focused-hidden-contenteditable.html [new file with mode: 0644]
LayoutTests/editing/selection/ios/hide-selection-after-hiding-contenteditable-expected.txt [new file with mode: 0644]
LayoutTests/editing/selection/ios/hide-selection-after-hiding-contenteditable.html [new file with mode: 0644]
LayoutTests/editing/selection/ios/hide-selection-in-contenteditable-nested-transparency-expected.txt [new file with mode: 0644]
LayoutTests/editing/selection/ios/hide-selection-in-contenteditable-nested-transparency.html [new file with mode: 0644]
LayoutTests/editing/selection/ios/hide-selection-in-hidden-contenteditable-expected.txt [new file with mode: 0644]
LayoutTests/editing/selection/ios/hide-selection-in-hidden-contenteditable-frame-expected.txt [new file with mode: 0644]
LayoutTests/editing/selection/ios/hide-selection-in-hidden-contenteditable-frame.html [new file with mode: 0644]
LayoutTests/editing/selection/ios/hide-selection-in-hidden-contenteditable.html [new file with mode: 0644]
LayoutTests/resources/ui-helper.js
Source/WebCore/ChangeLog
Source/WebCore/rendering/RenderObject.cpp
Source/WebCore/rendering/RenderObject.h
Source/WebKit/ChangeLog
Source/WebKit/Shared/AssistedNodeInformation.cpp
Source/WebKit/Shared/AssistedNodeInformation.h
Source/WebKit/Shared/EditorState.cpp
Source/WebKit/Shared/EditorState.h
Source/WebKit/UIProcess/ios/WKContentViewInteraction.mm
Source/WebKit/WebProcess/WebPage/ios/WebPageIOS.mm
Tools/ChangeLog
Tools/DumpRenderTree/ios/UIScriptControllerIOS.mm
Tools/TestRunnerShared/UIScriptContext/Bindings/UIScriptController.idl
Tools/TestRunnerShared/UIScriptContext/UIScriptController.cpp
Tools/TestRunnerShared/UIScriptContext/UIScriptController.h
Tools/WebKitTestRunner/ios/UIScriptControllerIOS.mm