Changeset 242794 in webkit


Ignore:
Timestamp:
Mar 12, 2019 7:45:31 AM (5 years ago)
Author:
Antti Koivisto
Message:

Compositing layer that renders two positioned elements should not hit test
https://bugs.webkit.org/show_bug.cgi?id=195371
<rdar://problem/48649586>

Reviewed by Simon Fraser.

Source/WebCore:

Compute and pass an event region for layers if it differs from layer bounds.

This patch fixes various block overflow and layer expansion cases. It does not handle
overflowing line boxes yet (it adds tests for those too).

Test: fast/scrolling/ios/overflow-scroll-overlap-2.html

  • platform/graphics/GraphicsLayer.cpp:

(WebCore::GraphicsLayer::setEventRegion):

  • platform/graphics/GraphicsLayer.h:

(WebCore::GraphicsLayer::eventRegion):

  • platform/graphics/Region.h:
  • platform/graphics/ca/GraphicsLayerCA.cpp:

(WebCore::GraphicsLayerCA::setEventRegion):
(WebCore::GraphicsLayerCA::commitLayerChangesBeforeSublayers):
(WebCore::GraphicsLayerCA::updateEventRegion):

Pass the region via the main platform layer of the graphics layer.

  • platform/graphics/ca/GraphicsLayerCA.h:
  • platform/graphics/ca/PlatformCALayer.h:
  • platform/graphics/ca/cocoa/PlatformCALayerCocoa.h:
  • rendering/PaintInfo.h:
  • rendering/PaintPhase.h:

Add EventRegion paint phase that computes the region instead of painting anything.

  • rendering/RenderBlock.cpp:

(WebCore::RenderBlock::paintObject):

  • rendering/RenderLayer.cpp:

(WebCore::RenderLayer::paintForegroundForFragments):
(WebCore::RenderLayer::paintForegroundForFragmentsWithPhase):

Invoke EventRegion paint phase.

  • rendering/RenderLayer.h:
  • rendering/RenderLayerBacking.cpp:

(WebCore::RenderLayerBacking::paintIntoLayer):

Request event region when pointing a layer.

Source/WebKit:

  • Shared/RemoteLayerTree/RemoteLayerTreePropertyApplier.mm:

(WebKit::RemoteLayerTreePropertyApplier::applyProperties):

  • Shared/RemoteLayerTree/RemoteLayerTreeTransaction.h:
  • Shared/RemoteLayerTree/RemoteLayerTreeTransaction.mm:

(WebKit::RemoteLayerTreeTransaction::LayerProperties::LayerProperties):
(WebKit::RemoteLayerTreeTransaction::LayerProperties::encode const):
(WebKit::RemoteLayerTreeTransaction::LayerProperties::decode):

Pass event region to UI process.

  • UIProcess/RemoteLayerTree/RemoteLayerTreeNode.h:

(WebKit::RemoteLayerTreeNode::layerID const):
(WebKit::RemoteLayerTreeNode::eventRegion const):

  • UIProcess/RemoteLayerTree/RemoteLayerTreeNode.mm:

(WebKit::RemoteLayerTreeNode::RemoteLayerTreeNode):
(WebKit::RemoteLayerTreeNode::~RemoteLayerTreeNode):
(WebKit::RemoteLayerTreeNode::setEventRegion):

Maintain event region in RemoteLayerTreeNodes.

(WebKit::RemoteLayerTreeNode::initializeLayer):
(WebKit::RemoteLayerTreeNode::layerID):
(WebKit::RemoteLayerTreeNode::forCALayer):

Move layerID to RemoteLayerTreeNode and store RemoteLayerTreeNode pointer to CALayers instead.
This makes it easy to find the matching RemoteLayerTreeNode from a layer, globally.

(WebKit::RemoteLayerTreeNode::setLayerID): Deleted.

  • UIProcess/RemoteLayerTree/ios/RemoteLayerTreeViews.mm:

(WebKit::collectDescendantViewsAtPoint):

If we have event region, use it for hit testing.

(-[UIView _web_findDescendantViewAtPoint:withEvent:]):
(collectDescendantViewsAtPoint): Deleted.

  • WebProcess/WebPage/RemoteLayerTree/PlatformCALayerRemote.cpp:

(WebKit::PlatformCALayerRemote::eventRegion const):
(WebKit::PlatformCALayerRemote::setEventRegion):

  • WebProcess/WebPage/RemoteLayerTree/PlatformCALayerRemote.h:

LayoutTests:

  • fast/scrolling/ios/overflow-scroll-overlap-2-expected.txt: Added.
  • fast/scrolling/ios/overflow-scroll-overlap-2.html: Added.
Location:
trunk
Files:
2 added
25 edited

Legend:

Unmodified
Added
Removed
  • trunk/LayoutTests/ChangeLog

    r242791 r242794  
     12019-03-12  Antti Koivisto  <antti@apple.com>
     2
     3        Compositing layer that renders two positioned elements should not hit test
     4        https://bugs.webkit.org/show_bug.cgi?id=195371
     5        <rdar://problem/48649586>
     6
     7        Reviewed by Simon Fraser.
     8
     9        * fast/scrolling/ios/overflow-scroll-overlap-2-expected.txt: Added.
     10        * fast/scrolling/ios/overflow-scroll-overlap-2.html: Added.
     11
    1122019-03-12  Enrique Ocaña González  <eocanha@igalia.com>
    213
  • trunk/Source/WebCore/ChangeLog

    r242793 r242794  
     12019-03-12  Antti Koivisto  <antti@apple.com>
     2
     3        Compositing layer that renders two positioned elements should not hit test
     4        https://bugs.webkit.org/show_bug.cgi?id=195371
     5        <rdar://problem/48649586>
     6
     7        Reviewed by Simon Fraser.
     8
     9        Compute and pass an event region for layers if it differs from layer bounds.
     10
     11        This patch fixes various block overflow and layer expansion cases. It does not handle
     12        overflowing line boxes yet (it adds tests for those too).
     13
     14        Test: fast/scrolling/ios/overflow-scroll-overlap-2.html
     15
     16        * platform/graphics/GraphicsLayer.cpp:
     17        (WebCore::GraphicsLayer::setEventRegion):
     18        * platform/graphics/GraphicsLayer.h:
     19        (WebCore::GraphicsLayer::eventRegion):
     20        * platform/graphics/Region.h:
     21        * platform/graphics/ca/GraphicsLayerCA.cpp:
     22        (WebCore::GraphicsLayerCA::setEventRegion):
     23        (WebCore::GraphicsLayerCA::commitLayerChangesBeforeSublayers):
     24        (WebCore::GraphicsLayerCA::updateEventRegion):
     25
     26        Pass the region via the main platform layer of the graphics layer.
     27
     28        * platform/graphics/ca/GraphicsLayerCA.h:
     29        * platform/graphics/ca/PlatformCALayer.h:
     30        * platform/graphics/ca/cocoa/PlatformCALayerCocoa.h:
     31        * rendering/PaintInfo.h:
     32        * rendering/PaintPhase.h:
     33
     34        Add EventRegion paint phase that computes the region instead of painting anything.
     35
     36        * rendering/RenderBlock.cpp:
     37        (WebCore::RenderBlock::paintObject):
     38        * rendering/RenderLayer.cpp:
     39        (WebCore::RenderLayer::paintForegroundForFragments):
     40        (WebCore::RenderLayer::paintForegroundForFragmentsWithPhase):
     41
     42        Invoke EventRegion paint phase.
     43
     44        * rendering/RenderLayer.h:
     45        * rendering/RenderLayerBacking.cpp:
     46        (WebCore::RenderLayerBacking::paintIntoLayer):
     47
     48        Request event region when pointing a layer.
     49
    1502019-03-12  Philippe Normand  <pnormand@igalia.com>
    251
  • trunk/Source/WebCore/platform/graphics/GraphicsLayer.cpp

    r241788 r242794  
    3232#include "GraphicsContext.h"
    3333#include "LayoutRect.h"
     34#include "Region.h"
    3435#include "RotateTransformOperation.h"
    3536#include <wtf/HashMap.h>
     
    410411    UNUSED_PARAM(windRule);
    411412#endif
     413}
     414
     415void GraphicsLayer::setEventRegion(std::unique_ptr<Region>&& eventRegion)
     416{
     417    m_eventRegion = WTFMove(eventRegion);
    412418}
    413419
  • trunk/Source/WebCore/platform/graphics/GraphicsLayer.h

    r240918 r242794  
    5555class GraphicsLayerFactory;
    5656class Image;
     57class Region;
    5758class TiledBacking;
    5859class TimingFunction;
     
    452453    WindRule shapeLayerWindRule() const;
    453454    virtual void setShapeLayerWindRule(WindRule);
     455
     456    // Non-null if the event sensitive region of the layer differs from the layer bounds.
     457    const Region* eventRegion() const { return m_eventRegion.get(); }
     458    virtual void setEventRegion(std::unique_ptr<Region>&&);
    454459
    455460    // Transitions are identified by a special animation name that cannot clash with a keyframe identifier.
     
    727732    Optional<FloatRect> m_animationExtent;
    728733
     734    std::unique_ptr<Region> m_eventRegion;
     735
    729736#if USE(CA)
    730737    WindRule m_shapeLayerWindRule { WindRule::NonZero };
  • trunk/Source/WebCore/platform/graphics/Region.h

    r202408 r242794  
    5454    WEBCORE_EXPORT bool contains(const Region&) const;
    5555
    56     bool contains(const IntPoint&) const;
     56    WEBCORE_EXPORT bool contains(const IntPoint&) const;
    5757
    5858    // Returns true if the query region intersects any part of this region.
    59     bool intersects(const Region&) const;
     59    WEBCORE_EXPORT bool intersects(const Region&) const;
    6060
    6161    WEBCORE_EXPORT unsigned totalArea() const;
  • trunk/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.cpp

    r241852 r242794  
    4040#include "PlatformCALayer.h"
    4141#include "PlatformScreen.h"
     42#include "Region.h"
    4243#include "RotateTransformOperation.h"
    4344#include "ScaleTransformOperation.h"
     
    5253#include <wtf/MathExtras.h>
    5354#include <wtf/NeverDestroyed.h>
     55#include <wtf/PointerComparison.h>
    5456#include <wtf/SetForScope.h>
    5557#include <wtf/SystemTracing.h>
     
    983985}
    984986
     987void GraphicsLayerCA::setEventRegion(std::unique_ptr<Region>&& eventRegion)
     988{
     989    if (arePointingToEqualData(eventRegion, m_eventRegion))
     990        return;
     991
     992    GraphicsLayer::setEventRegion(WTFMove(eventRegion));
     993    noteLayerPropertyChanged(EventRegionChanged, DontScheduleFlush);
     994}
     995
    985996bool GraphicsLayerCA::shouldRepaintOnSizeChange() const
    986997{
     
    18451856        updateMasksToBoundsRect();
    18461857
     1858    if (m_uncommittedChanges & EventRegionChanged)
     1859        updateEventRegion();
     1860
    18471861    if (m_uncommittedChanges & MaskLayerChanged) {
    18481862        updateMaskLayer();
     
    18541868    if (m_uncommittedChanges & ContentsNeedsDisplay)
    18551869        updateContentsNeedsDisplay();
    1856    
     1870
    18571871    if (m_uncommittedChanges & SupportsSubpixelAntialiasedTextChanged)
    18581872        updateSupportsSubpixelAntialiasedText();
     
    27542768        }
    27552769    }
     2770}
     2771
     2772void GraphicsLayerCA::updateEventRegion()
     2773{
     2774    m_layer->setEventRegion(eventRegion());
    27562775}
    27572776
  • trunk/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.h

    r240047 r242794  
    125125    WEBCORE_EXPORT void setShapeLayerWindRule(WindRule) override;
    126126
     127    WEBCORE_EXPORT void setEventRegion(std::unique_ptr<Region>&&) override;
     128
    127129    WEBCORE_EXPORT void suspendAnimations(MonotonicTime) override;
    128130    WEBCORE_EXPORT void resumeAnimations() override;
     
    414416    void updateContentsRects();
    415417    void updateMasksToBoundsRect();
     418    void updateEventRegion();
    416419    void updateMaskLayer();
    417420    void updateReplicatedLayers();
     
    532535        UserInteractionEnabledChanged           = 1LLU << 38,
    533536        NeedsComputeVisibleAndCoverageRect      = 1LLU << 39,
     537        EventRegionChanged                      = 1LLU << 40,
    534538    };
    535539    typedef uint64_t LayerChangeFlags;
  • trunk/Source/WebCore/platform/graphics/ca/PlatformCALayer.h

    r240918 r242794  
    234234    virtual WindRule shapeWindRule() const = 0;
    235235    virtual void setShapeWindRule(WindRule) = 0;
     236
     237    virtual const Region* eventRegion() const = 0;
     238    virtual void setEventRegion(const Region*) = 0;
    236239   
    237240    virtual GraphicsLayer::CustomAppearance customAppearance() const = 0;
  • trunk/Source/WebCore/platform/graphics/ca/cocoa/PlatformCALayerCocoa.h

    r238108 r242794  
    169169    void updateCustomAppearance(GraphicsLayer::CustomAppearance) override;
    170170
     171    const Region* eventRegion() const override { return nullptr; }
     172    void setEventRegion(const Region*) override { }
     173
    171174    GraphicsLayer::EmbeddedViewID embeddedViewID() const override;
    172175
  • trunk/Source/WebCore/platform/graphics/ca/win/PlatformCALayerWin.h

    r238152 r242794  
    158158    void updateCustomAppearance(GraphicsLayer::CustomAppearance customAppearance) override { m_customAppearance = customAppearance; }
    159159
     160    const Region* eventRegion() const override { return nullptr; }
     161    void setEventRegion(const Region*) override { }
     162
    160163    GraphicsLayer::EmbeddedViewID embeddedViewID() const override;
    161164
  • trunk/Source/WebCore/rendering/PaintInfo.h

    r239461 r242794  
    3939
    4040class OverlapTestRequestClient;
     41class Region;
    4142class RenderInline;
    4243class RenderLayer;
     
    130131    bool requireSecurityOriginAccessForWidgets { false };
    131132    const RenderLayer* m_enclosingSelfPaintingLayer { nullptr };
     133    Region* eventRegion { nullptr }; // For PaintPhase::EventRegion.
    132134
    133135private:
  • trunk/Source/WebCore/rendering/PaintPhase.h

    r234619 r242794  
    5050    TextClip,
    5151    Mask,
    52     ClippingMask
     52    ClippingMask,
     53    EventRegion,
    5354};
    5455
  • trunk/Source/WebCore/rendering/RenderBlock.cpp

    r240641 r242794  
    12411241        return;
    12421242
     1243    if (paintPhase == PaintPhase::EventRegion) {
     1244        // FIXME: Handle inlines, lineboxes, SVG too.
     1245        // FIXME: Transforms?
     1246        if (style().pointerEvents() != PointerEvents::None)
     1247            paintInfo.eventRegion->unite(enclosingIntRect(LayoutRect(paintOffset, size())));
     1248
     1249        // No need to check descendants if we don't have overflow.
     1250        if (!hasVisualOverflow())
     1251            return;
     1252    }
     1253
    12431254    // Adjust our painting position if we're inside a scrolled layer (e.g., an overflow:auto div).
    12441255    LayoutPoint scrolledOffset = paintOffset;
  • trunk/Source/WebCore/rendering/RenderLayer.cpp

    r242561 r242794  
    47474747        paintForegroundForFragmentsWithPhase(PaintPhase::Foreground, layerFragments, context, localPaintingInfo, localPaintBehavior, subtreePaintRootForRenderer);
    47484748        paintForegroundForFragmentsWithPhase(PaintPhase::ChildOutlines, layerFragments, context, localPaintingInfo, localPaintBehavior, subtreePaintRootForRenderer);
     4749        if (localPaintingInfo.eventRegion)
     4750            paintForegroundForFragmentsWithPhase(PaintPhase::EventRegion, layerFragments, context, localPaintingInfo, localPaintBehavior, subtreePaintRootForRenderer);
    47494751    }
    47504752   
     
    47684770        if (phase == PaintPhase::Foreground)
    47694771            paintInfo.overlapTestRequests = localPaintingInfo.overlapTestRequests;
     4772        if (phase == PaintPhase::EventRegion)
     4773            paintInfo.eventRegion = localPaintingInfo.eventRegion;
    47704774        renderer().paint(paintInfo, toLayoutPoint(fragment.layerBounds.location() - renderBoxLocation() + localPaintingInfo.subpixelOffset));
    47714775       
  • trunk/Source/WebCore/rendering/RenderLayer.h

    r242561 r242794  
    6767class HitTestResult;
    6868class HitTestingTransformState;
     69class Region;
    6970class RenderFragmentedFlow;
    7071class RenderGeometryMap;
     
    906907        bool requireSecurityOriginAccessForWidgets;
    907908        bool clipToDirtyRect { true };
     909        Region* eventRegion { nullptr };
    908910    };
    909911
  • trunk/Source/WebCore/rendering/RenderLayerBacking.cpp

    r242700 r242794  
    5252#include "PluginViewBase.h"
    5353#include "ProgressTracker.h"
     54#include "Region.h"
    5455#include "RenderFragmentContainer.h"
    5556#include "RenderFragmentedFlow.h"
     
    25742575        renderer().view().frameView().willPaintContents(context, paintDirtyRect, paintingState);
    25752576
    2576     // FIXME: GraphicsLayers need a way to split for RenderFragmentContainers.
    25772577    RenderLayer::LayerPaintingInfo paintingInfo(&m_owningLayer, paintDirtyRect, paintBehavior, -m_subpixelOffsetFromRenderer);
     2578
     2579    auto eventRegion = std::make_unique<Region>();
     2580    paintingInfo.eventRegion = eventRegion.get();
     2581
    25782582    m_owningLayer.paintLayerContents(context, paintingInfo, paintFlags);
     2583
     2584    paintingInfo.eventRegion = nullptr;
     2585    // Use null event region to indicate the entire layer is sensitive to events (the common case).
     2586    // FIXME: We could optimize Region so it doesn't use lots of memory if it contains a single rect only.
     2587    if (eventRegion->contains(roundedIntRect(compositedBounds())))
     2588        eventRegion = nullptr;
     2589    else
     2590        eventRegion->translate(roundedIntSize(contentOffsetInCompositingLayer()));
     2591    m_graphicsLayer->setEventRegion(WTFMove(eventRegion));
    25792592
    25802593    if (m_owningLayer.containsDirtyOverlayScrollbars())
  • trunk/Source/WebKit/ChangeLog

    r242788 r242794  
     12019-03-12  Antti Koivisto  <antti@apple.com>
     2
     3        Compositing layer that renders two positioned elements should not hit test
     4        https://bugs.webkit.org/show_bug.cgi?id=195371
     5        <rdar://problem/48649586>
     6
     7        Reviewed by Simon Fraser.
     8
     9        * Shared/RemoteLayerTree/RemoteLayerTreePropertyApplier.mm:
     10        (WebKit::RemoteLayerTreePropertyApplier::applyProperties):
     11        * Shared/RemoteLayerTree/RemoteLayerTreeTransaction.h:
     12        * Shared/RemoteLayerTree/RemoteLayerTreeTransaction.mm:
     13        (WebKit::RemoteLayerTreeTransaction::LayerProperties::LayerProperties):
     14        (WebKit::RemoteLayerTreeTransaction::LayerProperties::encode const):
     15        (WebKit::RemoteLayerTreeTransaction::LayerProperties::decode):
     16
     17        Pass event region to UI process.
     18
     19        * UIProcess/RemoteLayerTree/RemoteLayerTreeNode.h:
     20        (WebKit::RemoteLayerTreeNode::layerID const):
     21        (WebKit::RemoteLayerTreeNode::eventRegion const):
     22        * UIProcess/RemoteLayerTree/RemoteLayerTreeNode.mm:
     23        (WebKit::RemoteLayerTreeNode::RemoteLayerTreeNode):
     24        (WebKit::RemoteLayerTreeNode::~RemoteLayerTreeNode):
     25        (WebKit::RemoteLayerTreeNode::setEventRegion):
     26
     27        Maintain event region in RemoteLayerTreeNodes.
     28
     29        (WebKit::RemoteLayerTreeNode::initializeLayer):
     30        (WebKit::RemoteLayerTreeNode::layerID):
     31        (WebKit::RemoteLayerTreeNode::forCALayer):
     32
     33        Move layerID to RemoteLayerTreeNode and store RemoteLayerTreeNode pointer to CALayers instead.
     34        This makes it easy to find the matching RemoteLayerTreeNode from a layer, globally.
     35
     36        (WebKit::RemoteLayerTreeNode::setLayerID): Deleted.
     37        * UIProcess/RemoteLayerTree/ios/RemoteLayerTreeViews.mm:
     38        (WebKit::collectDescendantViewsAtPoint):
     39
     40        If we have event region, use it for hit testing.
     41
     42        (-[UIView _web_findDescendantViewAtPoint:withEvent:]):
     43        (collectDescendantViewsAtPoint): Deleted.
     44        * WebProcess/WebPage/RemoteLayerTree/PlatformCALayerRemote.cpp:
     45        (WebKit::PlatformCALayerRemote::eventRegion const):
     46        (WebKit::PlatformCALayerRemote::setEventRegion):
     47        * WebProcess/WebPage/RemoteLayerTree/PlatformCALayerRemote.h:
     48
    1492019-03-12  Carlos Garcia Campos  <cgarcia@igalia.com>
    250
  • trunk/Source/WebKit/Shared/RemoteLayerTree/RemoteLayerTreePropertyApplier.mm

    r240717 r242794  
    262262    updateMask(node, properties, relatedLayers);
    263263
     264    if (properties.changedProperties & RemoteLayerTreeTransaction::EventRegionChanged)
     265        node.setEventRegion(properties.eventRegion ? std::make_unique<WebCore::Region>(*properties.eventRegion) : nullptr);
     266
    264267#if PLATFORM(IOS_FAMILY)
    265268    applyPropertiesToUIView(node.uiView(), properties, relatedLayers);
  • trunk/Source/WebKit/Shared/RemoteLayerTree/RemoteLayerTreeTransaction.h

    r241899 r242794  
    9393        CustomAppearanceChanged         = 1LLU << 36,
    9494        UserInteractionEnabledChanged   = 1LLU << 37,
     95        EventRegionChanged              = 1LLU << 38,
    9596    };
    9697
     
    172173        bool contentsHidden;
    173174        bool userInteractionEnabled;
     175        std::unique_ptr<WebCore::Region> eventRegion;
    174176    };
    175177
  • trunk/Source/WebKit/Shared/RemoteLayerTree/RemoteLayerTreeTransaction.mm

    r239427 r242794  
    3333#import <QuartzCore/QuartzCore.h>
    3434#import <WebCore/LengthFunctions.h>
     35#import <WebCore/Region.h>
    3536#import <WebCore/TimingFunction.h>
    3637#import <wtf/text/CString.h>
     
    155156    if (other.filters)
    156157        filters = std::make_unique<WebCore::FilterOperations>(*other.filters);
     158
     159    if (other.eventRegion)
     160        eventRegion = std::make_unique<WebCore::Region>(*other.eventRegion);
     161
    157162}
    158163
     
    277282    if (changedProperties & UserInteractionEnabledChanged)
    278283        encoder << userInteractionEnabled;
     284
     285    if (changedProperties & EventRegionChanged) {
     286        encoder << !!eventRegion;
     287        if (eventRegion)
     288            encoder << *eventRegion;
     289    }
    279290}
    280291
     
    498509        if (!decoder.decode(result.userInteractionEnabled))
    499510            return false;
     511    }
     512
     513    if (result.changedProperties & EventRegionChanged) {
     514        bool hasEventRegion = false;
     515        if (!decoder.decode(hasEventRegion))
     516            return false;
     517        if (hasEventRegion) {
     518            auto eventRegion = std::make_unique<WebCore::Region>();
     519            if (!decoder.decode(*eventRegion))
     520                return false;
     521            result.eventRegion = WTFMove(eventRegion);
     522        }
    500523    }
    501524
  • trunk/Source/WebKit/UIProcess/RemoteLayerTree/RemoteLayerTreeNode.h

    r239689 r242794  
    5454#endif
    5555
     56    WebCore::GraphicsLayer::PlatformLayerID layerID() const { return m_layerID; }
     57
     58    const WebCore::Region* eventRegion() const { return m_eventRegion.get(); }
     59    void setEventRegion(std::unique_ptr<WebCore::Region>&&);
     60
    5661    void detachFromParent();
    5762
    5863    static WebCore::GraphicsLayer::PlatformLayerID layerID(CALayer *);
     64    static RemoteLayerTreeNode* forCALayer(CALayer *);
     65
    5966    static NSString *appendLayerDescription(NSString *description, CALayer *);
    6067
    6168private:
    62     void setLayerID(WebCore::GraphicsLayer::PlatformLayerID);
     69    void initializeLayer();
     70
     71    WebCore::GraphicsLayer::PlatformLayerID m_layerID;
    6372
    6473    RetainPtr<CALayer> m_layer;
     
    6675    RetainPtr<UIView> m_uiView;
    6776#endif
     77
     78    std::unique_ptr<WebCore::Region> m_eventRegion;
    6879};
    6980
  • trunk/Source/WebKit/UIProcess/RemoteLayerTree/RemoteLayerTreeNode.mm

    r238547 r242794  
    4646namespace WebKit {
    4747
     48static NSString *const WKRemoteLayerTreeNodePropertyKey = @"WKRemoteLayerTreeNode";
     49
    4850RemoteLayerTreeNode::RemoteLayerTreeNode(WebCore::GraphicsLayer::PlatformLayerID layerID, RetainPtr<CALayer> layer)
    49     : m_layer(WTFMove(layer))
     51    : m_layerID(layerID)
     52    , m_layer(WTFMove(layer))
    5053{
    51     setLayerID(layerID);
     54    initializeLayer();
    5255    [m_layer setDelegate:[WebActionDisablingCALayerDelegate shared]];
    5356}
     
    5558#if PLATFORM(IOS_FAMILY)
    5659RemoteLayerTreeNode::RemoteLayerTreeNode(WebCore::GraphicsLayer::PlatformLayerID layerID, RetainPtr<UIView> uiView)
    57     : m_layer([uiView.get() layer])
     60    : m_layerID(layerID)
     61    , m_layer([uiView.get() layer])
    5862    , m_uiView(WTFMove(uiView))
    5963{
    60     setLayerID(layerID);
     64    initializeLayer();
    6165}
    6266#endif
    6367
    64 RemoteLayerTreeNode::~RemoteLayerTreeNode() = default;
     68RemoteLayerTreeNode::~RemoteLayerTreeNode()
     69{
     70    [layer() setValue:nil forKey:WKRemoteLayerTreeNodePropertyKey];
     71}
    6572
    6673std::unique_ptr<RemoteLayerTreeNode> RemoteLayerTreeNode::createWithPlainLayer(WebCore::GraphicsLayer::PlatformLayerID layerID)
     
    8188}
    8289
    83 static NSString *const WKLayerIDPropertyKey = @"WKLayerID";
     90void RemoteLayerTreeNode::setEventRegion(std::unique_ptr<WebCore::Region>&& eventRegion)
     91{
     92    m_eventRegion = WTFMove(eventRegion);
     93}
    8494
    85 void RemoteLayerTreeNode::setLayerID(WebCore::GraphicsLayer::PlatformLayerID layerID)
     95void RemoteLayerTreeNode::initializeLayer()
    8696{
    87     [layer() setValue:@(layerID) forKey:WKLayerIDPropertyKey];
     97    [layer() setValue:[NSValue valueWithPointer:this] forKey:WKRemoteLayerTreeNodePropertyKey];
    8898}
    8999
    90100WebCore::GraphicsLayer::PlatformLayerID RemoteLayerTreeNode::layerID(CALayer *layer)
    91101{
    92     return [[layer valueForKey:WKLayerIDPropertyKey] unsignedLongLongValue];
     102    auto* node = forCALayer(layer);
     103    return node ? node->layerID() : 0;
     104}
     105
     106RemoteLayerTreeNode* RemoteLayerTreeNode::forCALayer(CALayer *layer)
     107{
     108    return static_cast<RemoteLayerTreeNode*>([[layer valueForKey:WKRemoteLayerTreeNodePropertyKey] pointerValue]);
    93109}
    94110
  • trunk/Source/WebKit/UIProcess/RemoteLayerTree/ios/RemoteLayerTreeViews.mm

    r242564 r242794  
    3030
    3131#import "RemoteLayerTreeHost.h"
     32#import "RemoteLayerTreeNode.h"
    3233#import "UIKitSPI.h"
    3334#import "WKDrawingView.h"
     35#import <WebCore/Region.h>
    3436#import <pal/spi/cocoa/QuartzCoreSPI.h>
    3537#import <wtf/SoftLinking.h>
     38
     39namespace WebKit {
    3640
    3741static void collectDescendantViewsAtPoint(Vector<UIView *, 16>& viewsAtPoint, UIView *parent, CGPoint point, UIEvent *event)
     
    5458        }();
    5559
    56         if (!isTransparent && [view pointInside:subviewPoint withEvent:event])
    57             viewsAtPoint.append(view);
     60        if (!isTransparent && [view pointInside:subviewPoint withEvent:event]) {
     61            auto* node = RemoteLayerTreeNode::forCALayer(view.layer);
     62            auto* eventRegion = node ? node->eventRegion() : nullptr;
     63            if (!eventRegion || eventRegion->contains(WebCore::IntPoint(subviewPoint)))
     64                viewsAtPoint.append(view);
     65        }
    5866
    5967        if (![view subviews])
     
    6472}
    6573
     74}
     75
    6676@interface UIView (WKHitTesting)
    6777- (UIView *)_web_findDescendantViewAtPoint:(CGPoint)point withEvent:(UIEvent *)event;
     
    7383{
    7484    Vector<UIView *, 16> viewsAtPoint;
    75     collectDescendantViewsAtPoint(viewsAtPoint, self, point, event);
     85    WebKit::collectDescendantViewsAtPoint(viewsAtPoint, self, point, event);
    7686
    7787    for (auto i = viewsAtPoint.size(); i--;) {
  • trunk/Source/WebKit/WebProcess/WebPage/RemoteLayerTree/PlatformCALayerRemote.cpp

    r241925 r242794  
    3939#import <WebCore/PlatformCALayerCocoa.h>
    4040#import <WebCore/TiledBacking.h>
     41#import <wtf/PointerComparison.h>
    4142
    4243namespace WebKit {
     
    871872}
    872873
     874const Region* PlatformCALayerRemote::eventRegion() const
     875{
     876    return m_properties.eventRegion.get();
     877}
     878
     879void PlatformCALayerRemote::setEventRegion(const WebCore::Region* eventRegion)
     880{
     881    const auto* oldEventRegion = m_properties.eventRegion.get();
     882    if (arePointingToEqualData(oldEventRegion, eventRegion))
     883        return;
     884
     885    m_properties.eventRegion = eventRegion ? std::make_unique<WebCore::Region>(*eventRegion) : nullptr;
     886    m_properties.notePropertiesChanged(RemoteLayerTreeTransaction::EventRegionChanged);
     887}
     888
    873889GraphicsLayer::EmbeddedViewID PlatformCALayerRemote::embeddedViewID() const
    874890{
  • trunk/Source/WebKit/WebProcess/WebPage/RemoteLayerTree/PlatformCALayerRemote.h

    r241899 r242794  
    175175    void updateCustomAppearance(WebCore::GraphicsLayer::CustomAppearance) override;
    176176
     177    const WebCore::Region* eventRegion() const override;
     178    void setEventRegion(const WebCore::Region*) override;
     179
    177180    WebCore::GraphicsLayer::EmbeddedViewID embeddedViewID() const override;
    178181
Note: See TracChangeset for help on using the changeset viewer.