Changeset 228264 in webkit


Ignore:
Timestamp:
Feb 8, 2018 2:01:43 AM (6 years ago)
Author:
fred.wang@free.fr
Message:

Add scrolling node types to distinguish main frames and subframes.
​https://bugs.webkit.org/show_bug.cgi?id=182533

Patch by Frederic Wang <​fwang@igalia.com> on 2018-02-08
Reviewed by Simon Fraser.

Source/WebCore:

This patch splits FrameScrollingNode type into two types: MainFrameScrollingNode and
SubframeScrollingNode. This is needed because new places in the code are likely to
distinguish them e.g. in ScrollingTreeScrollingNodeDelegateIOS::updateChildNodesAfterScroll
or when iOS frame scrolling is introduced (see bug 173833).

No new tests, behavior unchanged.

  • page/scrolling/AsyncScrollingCoordinator.cpp:

(WebCore::AsyncScrollingCoordinator::ensureRootStateNodeForFrameView): This is only called
for main frames, so pass MainFrameScrollingNode.

  • page/scrolling/ScrollingCoordinator.cpp:

(WebCore::operator<<): Distinguish subframe and main frame when dumping.

  • page/scrolling/ScrollingCoordinator.h: Split FrameScrollingNode into two cases.
  • page/scrolling/ScrollingStateFrameScrollingNode.cpp: Add node type to constructor and

ASSERT it remains of type FrameScrollingNode.
(WebCore::ScrollingStateFrameScrollingNode::create):
(WebCore::ScrollingStateFrameScrollingNode::ScrollingStateFrameScrollingNode):

  • page/scrolling/ScrollingStateFrameScrollingNode.h: Add node type to constructor.
  • page/scrolling/ScrollingStateNode.h:

(WebCore::ScrollingStateNode::isFrameScrollingNode const): Includes the two cases.

  • page/scrolling/ScrollingStateTree.cpp:

(WebCore::ScrollingStateTree::createNode): Split FrameScrollingNode into two cases and pass
the node type.
(WebCore::ScrollingStateTree::attachNode): The first case only happens for main frames while
the second case only happens with subframes. Use the appriate node type.

  • page/scrolling/ScrollingTreeFrameScrollingNode.cpp: Add node type to constructor and

ASSERT it remains of type FrameScrollingNode.
(WebCore::ScrollingTreeFrameScrollingNode::ScrollingTreeFrameScrollingNode):

  • page/scrolling/ScrollingTreeFrameScrollingNode.h: Add node type to constructor.
  • page/scrolling/ScrollingTreeNode.h: Includes the two cases.

(WebCore::ScrollingTreeNode::isFrameScrollingNode const):

  • page/scrolling/ios/ScrollingTreeFrameScrollingNodeIOS.h: Add node type to constructor.
  • page/scrolling/ios/ScrollingTreeFrameScrollingNodeIOS.mm: Ditto.

(WebCore::ScrollingTreeFrameScrollingNodeIOS::create):
(WebCore::ScrollingTreeFrameScrollingNodeIOS::ScrollingTreeFrameScrollingNodeIOS):

  • page/scrolling/ios/ScrollingTreeIOS.cpp: Split FrameScrollingNode into two cases.

(WebCore::ScrollingTreeIOS::createScrollingTreeNode):

  • page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.h: Add node type to constructor.
  • page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm: Ditto.

(WebCore::ScrollingTreeFrameScrollingNodeMac::create):
(WebCore::ScrollingTreeFrameScrollingNodeMac::ScrollingTreeFrameScrollingNodeMac):

  • page/scrolling/mac/ScrollingTreeMac.cpp: Split FrameScrollingNode into two cases.

(ScrollingTreeMac::createScrollingTreeNode):

  • rendering/RenderLayerCompositor.cpp:

(WebCore::RenderLayerCompositor::reattachSubframeScrollLayers): Distinguish the cases of
main frames and subframes.
(WebCore::scrollCoordinationRoleForNodeType): Split FrameScrollingNode into two cases.
(WebCore::RenderLayerCompositor::updateScrollCoordinationForThisFrame): Distinguish the cases
of main frames and subframes.
(WebCore::RenderLayerCompositor::updateScrollCoordinatedLayer): Split FrameScrollingNode into
two cases.

Source/WebKit:

  • Shared/RemoteLayerTree/RemoteScrollingCoordinatorTransaction.cpp: Replace the case of

FrameScrollingNode with MainFrameScrollingNode and SubframeScrollingNode.
(WebKit::encodeNodeAndDescendants):
(WebKit::RemoteScrollingCoordinatorTransaction::decode):
(WebKit::dump):

  • UIProcess/RemoteLayerTree/RemoteScrollingCoordinatorProxy.cpp: Ditto.

(WebKit::RemoteScrollingCoordinatorProxy::connectStateNodeLayers):

  • UIProcess/RemoteLayerTree/RemoteScrollingTree.cpp: Ditto and pass the node type to the

constructor of the frame scrolling node.
(WebKit::RemoteScrollingTree::createScrollingTreeNode):

  • UIProcess/RemoteLayerTree/ios/RemoteScrollingCoordinatorProxyIOS.mm: Replace the case of

FrameScrollingNode with MainFrameScrollingNode and SubframeScrollingNode.
(WebKit::RemoteScrollingCoordinatorProxy::connectStateNodeLayers):

  • UIProcess/RemoteLayerTree/ios/ScrollingTreeScrollingNodeDelegateIOS.mm: In order to

determine whether the node is a main frame or subframe, use the node type instead of checking
whether the node as a parent.
(WebKit::ScrollingTreeScrollingNodeDelegateIOS::updateChildNodesAfterScroll):

Location:
trunk/Source
Files:
24 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r228263 r228264  
     12018-02-08  Frederic Wang  <fwang@igalia.com>
     2
     3        Add scrolling node types to distinguish main frames and subframes.
     4        https://bugs.webkit.org/show_bug.cgi?id=182533
     5
     6        Reviewed by Simon Fraser.
     7
     8        This patch splits FrameScrollingNode type into two types: MainFrameScrollingNode and
     9        SubframeScrollingNode. This is needed because new places in the code are likely to
     10        distinguish them e.g. in ScrollingTreeScrollingNodeDelegateIOS::updateChildNodesAfterScroll
     11        or when iOS frame scrolling is introduced (see bug 173833).
     12
     13        No new tests, behavior unchanged.
     14
     15        * page/scrolling/AsyncScrollingCoordinator.cpp:
     16        (WebCore::AsyncScrollingCoordinator::ensureRootStateNodeForFrameView): This is only called
     17        for main frames, so pass MainFrameScrollingNode.
     18        * page/scrolling/ScrollingCoordinator.cpp:
     19        (WebCore::operator<<): Distinguish subframe and main frame when dumping.
     20        * page/scrolling/ScrollingCoordinator.h: Split FrameScrollingNode into two cases.
     21        * page/scrolling/ScrollingStateFrameScrollingNode.cpp: Add node type to constructor and
     22        ASSERT it remains of type FrameScrollingNode.
     23        (WebCore::ScrollingStateFrameScrollingNode::create):
     24        (WebCore::ScrollingStateFrameScrollingNode::ScrollingStateFrameScrollingNode):
     25        * page/scrolling/ScrollingStateFrameScrollingNode.h: Add node type to constructor.
     26        * page/scrolling/ScrollingStateNode.h:
     27        (WebCore::ScrollingStateNode::isFrameScrollingNode const): Includes the two cases.
     28        * page/scrolling/ScrollingStateTree.cpp:
     29        (WebCore::ScrollingStateTree::createNode): Split FrameScrollingNode into two cases and pass
     30        the node type.
     31        (WebCore::ScrollingStateTree::attachNode): The first case only happens for main frames while
     32        the second case only happens with subframes. Use the appriate node type.
     33        * page/scrolling/ScrollingTreeFrameScrollingNode.cpp: Add node type to constructor and
     34        ASSERT it remains of type FrameScrollingNode.
     35        (WebCore::ScrollingTreeFrameScrollingNode::ScrollingTreeFrameScrollingNode):
     36        * page/scrolling/ScrollingTreeFrameScrollingNode.h: Add node type to constructor.
     37        * page/scrolling/ScrollingTreeNode.h: Includes the two cases.
     38        (WebCore::ScrollingTreeNode::isFrameScrollingNode const):
     39        * page/scrolling/ios/ScrollingTreeFrameScrollingNodeIOS.h: Add node type to constructor.
     40        * page/scrolling/ios/ScrollingTreeFrameScrollingNodeIOS.mm: Ditto.
     41        (WebCore::ScrollingTreeFrameScrollingNodeIOS::create):
     42        (WebCore::ScrollingTreeFrameScrollingNodeIOS::ScrollingTreeFrameScrollingNodeIOS):
     43        * page/scrolling/ios/ScrollingTreeIOS.cpp: Split FrameScrollingNode into two cases.
     44        (WebCore::ScrollingTreeIOS::createScrollingTreeNode):
     45        * page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.h: Add node type to constructor.
     46        * page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm: Ditto.
     47        (WebCore::ScrollingTreeFrameScrollingNodeMac::create):
     48        (WebCore::ScrollingTreeFrameScrollingNodeMac::ScrollingTreeFrameScrollingNodeMac):
     49        * page/scrolling/mac/ScrollingTreeMac.cpp: Split FrameScrollingNode into two cases.
     50        (ScrollingTreeMac::createScrollingTreeNode):
     51        * rendering/RenderLayerCompositor.cpp:
     52        (WebCore::RenderLayerCompositor::reattachSubframeScrollLayers): Distinguish the cases of
     53        main frames and subframes.
     54        (WebCore::scrollCoordinationRoleForNodeType): Split FrameScrollingNode into two cases.
     55        (WebCore::RenderLayerCompositor::updateScrollCoordinationForThisFrame): Distinguish the cases
     56        of main frames and subframes.
     57        (WebCore::RenderLayerCompositor::updateScrollCoordinatedLayer): Split FrameScrollingNode into
     58        two cases.
     59
    1602018-02-07  Darin Adler  <darin@apple.com>
    261

  • trunk/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp

    r227596 r228264  
    506506    // RenderLayerCompositor::updateBacking where the node has already been created.
    507507    ASSERT(frameView.frame().isMainFrame());
    508     attachToStateTree(FrameScrollingNode, frameView.scrollLayerID(), 0);
     508    attachToStateTree(MainFrameScrollingNode, frameView.scrollLayerID(), 0);
    509509}
    510510

  • trunk/Source/WebCore/page/scrolling/ScrollingCoordinator.cpp

    r223339 r228264  
    426426{
    427427    switch (nodeType) {
    428     case FrameScrollingNode:
    429         ts << "frame-scrolling";
     428    case MainFrameScrollingNode:
     429        ts << "main-frame-scrolling";
     430        break;
     431    case SubframeScrollingNode:
     432        ts << "subframe-scrolling";
    430433        break;
    431434    case OverflowScrollingNode:

  • trunk/Source/WebCore/page/scrolling/ScrollingCoordinator.h

    r220503 r228264  
    5555typedef uint64_t ScrollingNodeID;
    5656
    57 enum ScrollingNodeType { FrameScrollingNode, OverflowScrollingNode, FixedNode, StickyNode };
     57enum ScrollingNodeType { MainFrameScrollingNode, SubframeScrollingNode, OverflowScrollingNode, FixedNode, StickyNode };
    5858
    5959enum ScrollingStateTreeAsTextBehaviorFlags {

  • trunk/Source/WebCore/page/scrolling/ScrollingStateFrameScrollingNode.cpp

    r225227 r228264  
    3434namespace WebCore {
    3535
    36 Ref<ScrollingStateFrameScrollingNode> ScrollingStateFrameScrollingNode::create(ScrollingStateTree& stateTree, ScrollingNodeID nodeID)
    37 {
    38     return adoptRef(*new ScrollingStateFrameScrollingNode(stateTree, nodeID));
    39 }
    40 
    41 ScrollingStateFrameScrollingNode::ScrollingStateFrameScrollingNode(ScrollingStateTree& stateTree, ScrollingNodeID nodeID)
    42     : ScrollingStateScrollingNode(stateTree, FrameScrollingNode, nodeID)
    43 {
     36Ref<ScrollingStateFrameScrollingNode> ScrollingStateFrameScrollingNode::create(ScrollingStateTree& stateTree, ScrollingNodeType nodeType, ScrollingNodeID nodeID)
     37{
     38    return adoptRef(*new ScrollingStateFrameScrollingNode(stateTree, nodeType, nodeID));
     39}
     40
     41ScrollingStateFrameScrollingNode::ScrollingStateFrameScrollingNode(ScrollingStateTree& stateTree, ScrollingNodeType nodeType, ScrollingNodeID nodeID)
     42    : ScrollingStateScrollingNode(stateTree, nodeType, nodeID)
     43{
     44    ASSERT(isFrameScrollingNode());
    4445}
    4546

  • trunk/Source/WebCore/page/scrolling/ScrollingStateFrameScrollingNode.h

    r220503 r228264  
    4040class ScrollingStateFrameScrollingNode final : public ScrollingStateScrollingNode {
    4141public:
    42     static Ref<ScrollingStateFrameScrollingNode> create(ScrollingStateTree&, ScrollingNodeID);
     42    static Ref<ScrollingStateFrameScrollingNode> create(ScrollingStateTree&, ScrollingNodeType, ScrollingNodeID);
    4343
    4444    Ref<ScrollingStateNode> clone(ScrollingStateTree&) override;
    … …  
    135135
    136136private:
    137     ScrollingStateFrameScrollingNode(ScrollingStateTree&, ScrollingNodeID);
     137    ScrollingStateFrameScrollingNode(ScrollingStateTree&, ScrollingNodeType, ScrollingNodeID);
    138138    ScrollingStateFrameScrollingNode(const ScrollingStateFrameScrollingNode&, ScrollingStateTree&);
    139139

  • trunk/Source/WebCore/page/scrolling/ScrollingStateNode.h

    r227596 r228264  
    198198    bool isStickyNode() const { return m_nodeType == StickyNode; }
    199199    bool isScrollingNode() const { return isFrameScrollingNode() || isOverflowScrollingNode(); }
    200     bool isFrameScrollingNode() const { return m_nodeType == FrameScrollingNode; }
     200    bool isFrameScrollingNode() const { return m_nodeType == MainFrameScrollingNode || m_nodeType == SubframeScrollingNode; }
    201201    bool isOverflowScrollingNode() const { return m_nodeType == OverflowScrollingNode; }
    202202

  • trunk/Source/WebCore/page/scrolling/ScrollingStateTree.cpp

    r223728 r228264  
    7373    case StickyNode:
    7474        return ScrollingStateStickyNode::create(*this, nodeID);
    75     case FrameScrollingNode:
    76         return ScrollingStateFrameScrollingNode::create(*this, nodeID);
     75    case MainFrameScrollingNode:
     76    case SubframeScrollingNode:
     77        return ScrollingStateFrameScrollingNode::create(*this, nodeType, nodeID);
    7778    case OverflowScrollingNode:
    7879        return ScrollingStateOverflowScrollingNode::create(*this, nodeID);
    … …  
    117118        clear();
    118119
    119         setRootStateNode(ScrollingStateFrameScrollingNode::create(*this, newNodeID));
     120        setRootStateNode(ScrollingStateFrameScrollingNode::create(*this, MainFrameScrollingNode, newNodeID));
    120121        newNode = rootStateNode();
    121122        m_hasNewRootStateNode = true;
    … …  
    125126            return 0;
    126127
    127         if (nodeType == FrameScrollingNode && parentID) {
     128        if (nodeType == SubframeScrollingNode && parentID) {
    128129            if (auto orphanedNode = m_orphanedSubframeNodes.take(newNodeID)) {
    129130                newNode = orphanedNode.get();

  • trunk/Source/WebCore/page/scrolling/ScrollingTreeFrameScrollingNode.cpp

    r223728 r228264  
    3737namespace WebCore {
    3838
    39 ScrollingTreeFrameScrollingNode::ScrollingTreeFrameScrollingNode(ScrollingTree& scrollingTree, ScrollingNodeID nodeID)
    40     : ScrollingTreeScrollingNode(scrollingTree, FrameScrollingNode, nodeID)
     39ScrollingTreeFrameScrollingNode::ScrollingTreeFrameScrollingNode(ScrollingTree& scrollingTree, ScrollingNodeType nodeType, ScrollingNodeID nodeID)
     40    : ScrollingTreeScrollingNode(scrollingTree, nodeType, nodeID)
    4141{
     42    ASSERT(isFrameScrollingNode());
    4243}
    4344

  • trunk/Source/WebCore/page/scrolling/ScrollingTreeFrameScrollingNode.h

    r220503 r228264  
    6262
    6363protected:
    64     ScrollingTreeFrameScrollingNode(ScrollingTree&, ScrollingNodeID);
     64    ScrollingTreeFrameScrollingNode(ScrollingTree&, ScrollingNodeType, ScrollingNodeID);
    6565
    6666    void scrollBy(const FloatSize&);

  • trunk/Source/WebCore/page/scrolling/ScrollingTreeNode.h

    r225480 r228264  
    5151    bool isStickyNode() const { return nodeType() == StickyNode; }
    5252    bool isScrollingNode() const { return isFrameScrollingNode() || isOverflowScrollingNode(); }
    53     bool isFrameScrollingNode() const { return nodeType() == FrameScrollingNode; }
     53    bool isFrameScrollingNode() const { return nodeType() == MainFrameScrollingNode || nodeType() == SubframeScrollingNode; }
    5454    bool isOverflowScrollingNode() const { return nodeType() == OverflowScrollingNode; }
    5555

  • trunk/Source/WebCore/page/scrolling/ios/ScrollingTreeFrameScrollingNodeIOS.h

    r208503 r228264  
    3737class ScrollingTreeFrameScrollingNodeIOS : public ScrollingTreeFrameScrollingNode {
    3838public:
    39     WEBCORE_EXPORT static Ref<ScrollingTreeFrameScrollingNodeIOS> create(ScrollingTree&, ScrollingNodeID);
     39    WEBCORE_EXPORT static Ref<ScrollingTreeFrameScrollingNodeIOS> create(ScrollingTree&, ScrollingNodeType, ScrollingNodeID);
    4040    virtual ~ScrollingTreeFrameScrollingNodeIOS();
    4141
    4242protected:
    43     ScrollingTreeFrameScrollingNodeIOS(ScrollingTree&, ScrollingNodeID);
     43    ScrollingTreeFrameScrollingNodeIOS(ScrollingTree&, ScrollingNodeType, ScrollingNodeID);
    4444
    4545    // ScrollingTreeNode member functions.

  • trunk/Source/WebCore/page/scrolling/ios/ScrollingTreeFrameScrollingNodeIOS.mm

    r210828 r228264  
    3939namespace WebCore {
    4040
    41 Ref<ScrollingTreeFrameScrollingNodeIOS> ScrollingTreeFrameScrollingNodeIOS::create(ScrollingTree& scrollingTree, ScrollingNodeID nodeID)
    42 {
    43     return adoptRef(*new ScrollingTreeFrameScrollingNodeIOS(scrollingTree, nodeID));
    44 }
    45 
    46 ScrollingTreeFrameScrollingNodeIOS::ScrollingTreeFrameScrollingNodeIOS(ScrollingTree& scrollingTree, ScrollingNodeID nodeID)
    47     : ScrollingTreeFrameScrollingNode(scrollingTree, nodeID)
     41Ref<ScrollingTreeFrameScrollingNodeIOS> ScrollingTreeFrameScrollingNodeIOS::create(ScrollingTree& scrollingTree, ScrollingNodeType nodeType, ScrollingNodeID nodeID)
     42{
     43    return adoptRef(*new ScrollingTreeFrameScrollingNodeIOS(scrollingTree, nodeType, nodeID));
     44}
     45
     46ScrollingTreeFrameScrollingNodeIOS::ScrollingTreeFrameScrollingNodeIOS(ScrollingTree& scrollingTree, ScrollingNodeType nodeType, ScrollingNodeID nodeID)
     47    : ScrollingTreeFrameScrollingNode(scrollingTree, nodeType, nodeID)
    4848{
    4949}

  • trunk/Source/WebCore/page/scrolling/ios/ScrollingTreeIOS.cpp

    r223476 r228264  
    8787{
    8888    switch (nodeType) {
    89     case FrameScrollingNode:
    90         return ScrollingTreeFrameScrollingNodeIOS::create(*this, nodeID);
     89    case MainFrameScrollingNode:
     90    case SubframeScrollingNode:
     91        return ScrollingTreeFrameScrollingNodeIOS::create(*this, nodeType, nodeID);
    9192    case OverflowScrollingNode:
    9293        ASSERT_NOT_REACHED();

  • trunk/Source/WebCore/page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.h

    r217737 r228264  
    3939class ScrollingTreeFrameScrollingNodeMac : public ScrollingTreeFrameScrollingNode, private ScrollControllerClient {
    4040public:
    41     WEBCORE_EXPORT static Ref<ScrollingTreeFrameScrollingNode> create(ScrollingTree&, ScrollingNodeID);
     41    WEBCORE_EXPORT static Ref<ScrollingTreeFrameScrollingNode> create(ScrollingTree&, ScrollingNodeType, ScrollingNodeID);
    4242    virtual ~ScrollingTreeFrameScrollingNodeMac();
    4343
    4444private:
    45     ScrollingTreeFrameScrollingNodeMac(ScrollingTree&, ScrollingNodeID);
     45    ScrollingTreeFrameScrollingNodeMac(ScrollingTree&, ScrollingNodeType, ScrollingNodeID);
    4646
    4747    void releaseReferencesToScrollerImpsOnTheMainThread();

  • trunk/Source/WebCore/page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm

    r220979 r228264  
    4949namespace WebCore {
    5050
    51 Ref<ScrollingTreeFrameScrollingNode> ScrollingTreeFrameScrollingNodeMac::create(ScrollingTree& scrollingTree, ScrollingNodeID nodeID)
    52 {
    53     return adoptRef(*new ScrollingTreeFrameScrollingNodeMac(scrollingTree, nodeID));
    54 }
    55 
    56 ScrollingTreeFrameScrollingNodeMac::ScrollingTreeFrameScrollingNodeMac(ScrollingTree& scrollingTree, ScrollingNodeID nodeID)
    57     : ScrollingTreeFrameScrollingNode(scrollingTree, nodeID)
     51Ref<ScrollingTreeFrameScrollingNode> ScrollingTreeFrameScrollingNodeMac::create(ScrollingTree& scrollingTree, ScrollingNodeType nodeType, ScrollingNodeID nodeID)
     52{
     53    return adoptRef(*new ScrollingTreeFrameScrollingNodeMac(scrollingTree, nodeType, nodeID));
     54}
     55
     56ScrollingTreeFrameScrollingNodeMac::ScrollingTreeFrameScrollingNodeMac(ScrollingTree& scrollingTree, ScrollingNodeType nodeType, ScrollingNodeID nodeID)
     57    : ScrollingTreeFrameScrollingNode(scrollingTree, nodeType, nodeID)
    5858    , m_scrollController(*this)
    5959    , m_verticalScrollerImp(nullptr)

  • trunk/Source/WebCore/page/scrolling/mac/ScrollingTreeMac.cpp

    r211033 r228264  
    4848{
    4949    switch (nodeType) {
    50     case FrameScrollingNode:
    51         return ScrollingTreeFrameScrollingNodeMac::create(*this, nodeID);
     50    case MainFrameScrollingNode:
     51    case SubframeScrollingNode:
     52        return ScrollingTreeFrameScrollingNodeMac::create(*this, nodeType, nodeID);
    5253    case OverflowScrollingNode:
    5354        ASSERT_NOT_REACHED();

  • trunk/Source/WebCore/rendering/RenderLayerCompositor.cpp

    r226521 r228264  
    36763676            continue;
    36773677
    3678         scrollingCoordinator->attachToStateTree(FrameScrollingNode, frameScrollingNodeID, parentNodeID);
     3678        scrollingCoordinator->attachToStateTree(child->isMainFrame() ? MainFrameScrollingNode : SubframeScrollingNode, frameScrollingNodeID, parentNodeID);
    36793679    }
    36803680}
    … …  
    36833683{
    36843684    switch (nodeType) {
    3685     case FrameScrollingNode:
     3685    case MainFrameScrollingNode:
     3686    case SubframeScrollingNode:
    36863687    case OverflowScrollingNode:
    36873688        return Scrolling;
    … …  
    37423743    ASSERT(scrollingCoordinator->coordinatesScrollingForFrameView(m_renderView.frameView()));
    37433744
    3744     ScrollingNodeID nodeID = attachScrollingNode(*m_renderView.layer(), FrameScrollingNode, parentNodeID);
     3745    ScrollingNodeID nodeID = attachScrollingNode(*m_renderView.layer(), m_renderView.frame().isMainFrame() ? MainFrameScrollingNode : SubframeScrollingNode, parentNodeID);
    37453746    scrollingCoordinator->updateFrameScrollingNode(nodeID, m_scrollLayer.get(), m_rootContentLayer.get(), fixedRootBackgroundLayer(), clipLayer());
    37463747}
    … …  
    37763777    // If a node plays both roles, fixed/sticky is always the ancestor node of scrolling.
    37773778    if (reasons & ViewportConstrained) {
    3778         ScrollingNodeType nodeType = FrameScrollingNode;
     3779        ScrollingNodeType nodeType = MainFrameScrollingNode;
    37793780        if (layer.renderer().isFixedPositioned())
    37803781            nodeType = FixedNode;
    … …  
    38013802                scrollingCoordinator->updateNodeViewportConstraints(nodeID, computeStickyViewportConstraints(layer));
    38023803                break;
    3803             case FrameScrollingNode:
     3804            case MainFrameScrollingNode:
     3805            case SubframeScrollingNode:
    38043806            case OverflowScrollingNode:
    38053807                break;

  • trunk/Source/WebKit/ChangeLog

    r228262 r228264  
     12018-02-08  Frederic Wang  <fwang@igalia.com>
     2
     3        Add scrolling node types to distinguish main frames and subframes.
     4        https://bugs.webkit.org/show_bug.cgi?id=182533
     5
     6        Reviewed by Simon Fraser.
     7
     8        * Shared/RemoteLayerTree/RemoteScrollingCoordinatorTransaction.cpp: Replace the case of
     9        FrameScrollingNode with MainFrameScrollingNode and SubframeScrollingNode.
     10        (WebKit::encodeNodeAndDescendants):
     11        (WebKit::RemoteScrollingCoordinatorTransaction::decode):
     12        (WebKit::dump):
     13        * UIProcess/RemoteLayerTree/RemoteScrollingCoordinatorProxy.cpp: Ditto.
     14        (WebKit::RemoteScrollingCoordinatorProxy::connectStateNodeLayers):
     15        * UIProcess/RemoteLayerTree/RemoteScrollingTree.cpp: Ditto and pass the node type to the
     16        constructor of the frame scrolling node.
     17        (WebKit::RemoteScrollingTree::createScrollingTreeNode):
     18        * UIProcess/RemoteLayerTree/ios/RemoteScrollingCoordinatorProxyIOS.mm: Replace the case of
     19        FrameScrollingNode with MainFrameScrollingNode and SubframeScrollingNode.
     20        (WebKit::RemoteScrollingCoordinatorProxy::connectStateNodeLayers):
     21        * UIProcess/RemoteLayerTree/ios/ScrollingTreeScrollingNodeDelegateIOS.mm: In order to
     22        determine whether the node is a main frame or subframe, use the node type instead of checking
     23        whether the node as a parent.
     24        (WebKit::ScrollingTreeScrollingNodeDelegateIOS::updateChildNodesAfterScroll):
     25
    1262018-02-05  Carlos Garcia Campos  <cgarcia@igalia.com>
    227

  • trunk/Source/WebKit/Shared/RemoteLayerTree/RemoteScrollingCoordinatorTransaction.cpp

    r223238 r228264  
    335335
    336336    switch (stateNode.nodeType()) {
    337     case FrameScrollingNode:
     337    case MainFrameScrollingNode:
     338    case SubframeScrollingNode:
    338339        encoder << downcast<ScrollingStateFrameScrollingNode>(stateNode);
    339340        break;
    … …  
    419420       
    420421        switch (nodeType) {
    421         case FrameScrollingNode:
     422        case MainFrameScrollingNode:
     423        case SubframeScrollingNode:
    422424            if (!decoder.decode(downcast<ScrollingStateFrameScrollingNode>(*newNode)))
    423425                return false;
    … …  
    562564   
    563565    switch (node.nodeType()) {
    564     case FrameScrollingNode:
     566    case MainFrameScrollingNode:
     567    case SubframeScrollingNode:
    565568        dump(ts, downcast<ScrollingStateFrameScrollingNode>(node), changedPropertiesOnly);
    566569        break;

  • trunk/Source/WebKit/UIProcess/RemoteLayerTree/RemoteScrollingCoordinatorProxy.cpp

    r221541 r228264  
    104104
    105105        switch (currNode->nodeType()) {
    106         case FrameScrollingNode: {
     106        case MainFrameScrollingNode:
     107        case SubframeScrollingNode: {
    107108            ScrollingStateFrameScrollingNode& scrollingStateNode = downcast<ScrollingStateFrameScrollingNode>(*currNode);
    108109           

  • trunk/Source/WebKit/UIProcess/RemoteLayerTree/RemoteScrollingTree.cpp

    r221541 r228264  
    114114{
    115115    switch (nodeType) {
    116     case FrameScrollingNode:
     116    case MainFrameScrollingNode:
     117    case SubframeScrollingNode:
    117118#if PLATFORM(IOS)
    118         return ScrollingTreeFrameScrollingNodeIOS::create(*this, nodeID);
     119        return ScrollingTreeFrameScrollingNodeIOS::create(*this, nodeType, nodeID);
    119120#else
    120         return ScrollingTreeFrameScrollingNodeMac::create(*this, nodeID);
     121        return ScrollingTreeFrameScrollingNodeMac::create(*this, nodeType, nodeID);
    121122#endif
    122123    case OverflowScrollingNode:

  • trunk/Source/WebKit/UIProcess/RemoteLayerTree/ios/RemoteScrollingCoordinatorProxyIOS.mm

    r221541 r228264  
    6868            break;
    6969        };
    70         case FrameScrollingNode: {
     70        case MainFrameScrollingNode:
     71        case SubframeScrollingNode: {
    7172            ScrollingStateFrameScrollingNode& scrollingStateNode = downcast<ScrollingStateFrameScrollingNode>(*currNode);
    7273           

  • trunk/Source/WebKit/UIProcess/RemoteLayerTree/ios/ScrollingTreeScrollingNodeDelegateIOS.mm

    r225480 r228264  
    248248    FloatRect fixedPositionRect;
    249249    auto* frameNode = scrollingNode().enclosingFrameNodeIncludingSelf();
    250     if (frameNode && frameNode->parent())
     250    if (frameNode && frameNode->nodeType() == SubframeScrollingNode)
    251251        fixedPositionRect = frameNode->fixedPositionRect();
    252252    else
Note: See TracChangeset for help on using the changeset viewer.