Attachment #356722 for bug #176914

View Details Raw Unified Return to Bug 176914

| Differences between



2018-12-06  Frederic Wang  <fwang@igalia.com>

        Allow control over child order when adding nodes to the scrolling tree
        https://bugs.webkit.org/show_bug.cgi?id=176914

        Reviewed by NOBODY (OOPS!).

        Based on an earlier patch by Simon Fraser.

        Previously ScrollingCoordinator just allowed nodes to be "attached" with a given parent,
        but with no control over sibling order. To allow for correct hit-testing overflow and
        frame scrolling nodes, we have to build the scrolling tree in z-order.

        This patch adds a 'childIndex' parameter to attachNode() which gives control over
        sibling order. For now, RenderLayerCompositor always uses the default 'notFound' value
        for childIndex so the current behavior (appending new nodes at the end of child list) is
        preserved.

        No new tests, behavior unchanged and already covered by existing tests.

        * page/scrolling/AsyncScrollingCoordinator.cpp:
        (WebCore::AsyncScrollingCoordinator::attachToStateTree):
        (WebCore::AsyncScrollingCoordinator::ensureRootStateNodeForFrameView):
        * page/scrolling/AsyncScrollingCoordinator.h:
        * page/scrolling/ScrollingCoordinator.h:
        (WebCore::ScrollingCoordinator::attachToStateTree):
        * page/scrolling/ScrollingStateNode.cpp:
        (WebCore::ScrollingStateNode::insertChild):
        (WebCore::ScrollingStateNode::indexOfChild const):
        * page/scrolling/ScrollingStateNode.h:
        * page/scrolling/ScrollingStateTree.cpp:
        (WebCore::ScrollingStateTree::nodeTypeAndParentMatch const):
        (WebCore::ScrollingStateTree::attachNode):
        * page/scrolling/ScrollingStateTree.h:

2018-12-05  Don Olmstead  <don.olmstead@sony.com>

        [PlayStation] Enable WebCore



        scrollableArea.horizontalScrollbarLayerDidChange();
}

ScrollingNodeID AsyncScrollingCoordinator::attachToStateTree(ScrollingNodeType nodeType, ScrollingNodeID newNodeID, ScrollingNodeID parentID, size_t childIndex)
{
    return m_scrollingStateTree->attachNode(nodeType, newNodeID, parentID, childIndex);
}

void AsyncScrollingCoordinator::detachFromStateTree(ScrollingNodeID nodeID)

    // For non-main frames, it is only possible to arrive in this function from
    // RenderLayerCompositor::updateBacking where the node has already been created.
    ASSERT(frameView.frame().isMainFrame());
    attachToStateTree(MainFrameScrollingNode, frameView.scrollLayerID(), 0, 0);
}

void AsyncScrollingCoordinator::updateFrameScrollingNode(ScrollingNodeID nodeID, GraphicsLayer* layer, GraphicsLayer* scrolledContentsLayer, GraphicsLayer* counterScrollingLayer, GraphicsLayer* insetClipLayer, const ScrollingGeometry& scrollingGeometry)

Lines 97-103 private: a/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.h_sec1
- a/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.h -1 / +1 lines
97		97
98	WEBCORE_EXPORT bool requestScrollPositionUpdate(FrameView&, const IntPoint&) override;	98	WEBCORE_EXPORT bool requestScrollPositionUpdate(FrameView&, const IntPoint&) override;
99		99
100	WEBCORE_EXPORT ScrollingNodeID attachToStateTree(ScrollingNodeType, ScrollingNodeID newNodeID, ScrollingNodeID parentID) override;	100	WEBCORE_EXPORT ScrollingNodeID attachToStateTree(ScrollingNodeType, ScrollingNodeID newNodeID, ScrollingNodeID parentID, size_t childIndex) override;
101	WEBCORE_EXPORT void detachFromStateTree(ScrollingNodeID) override;	101	WEBCORE_EXPORT void detachFromStateTree(ScrollingNodeID) override;
102	WEBCORE_EXPORT void clearStateTree() override;	102	WEBCORE_EXPORT void clearStateTree() override;
103		103



    virtual void commitTreeStateIfNeeded() { }
    virtual bool requestScrollPositionUpdate(FrameView&, const IntPoint&) { return false; }
    virtual bool handleWheelEvent(FrameView&, const PlatformWheelEvent&) { return true; }
    virtual ScrollingNodeID attachToStateTree(ScrollingNodeType, ScrollingNodeID newNodeID, ScrollingNodeID /*parentID*/, size_t /*childIndex*/ = notFound) { return newNodeID; }

    virtual void detachFromStateTree(ScrollingNodeID) { }
    virtual void clearStateTree() { }




    m_children->append(WTFMove(childNode));
}

void ScrollingStateNode::insertChild(Ref<ScrollingStateNode>&& childNode, size_t index)
{
    childNode->setParent(this);

    if (!m_children) {
        ASSERT(!index);
        m_children = std::make_unique<Vector<RefPtr<ScrollingStateNode>>>();
    }

    m_children->insert(index, WTFMove(childNode));
}

size_t ScrollingStateNode::indexOfChild(ScrollingStateNode& childNode) const
{
    if (!m_children)
        return notFound;

    return m_children->find(&childNode);
}

void ScrollingStateNode::reconcileLayerPositionForViewportRect(const LayoutRect& viewportRect, ScrollingLayerPositionAction action)
{
    if (!m_children)

Lines 236-241 public: a/Source/WebCore/page/scrolling/ScrollingStateNode.h_sec1
- a/Source/WebCore/page/scrolling/ScrollingStateNode.h +3 lines
236	Vector<RefPtr<ScrollingStateNode>>* children() const { return m_children.get(); }	236	Vector<RefPtr<ScrollingStateNode>>* children() const { return m_children.get(); }
237		237
238	void appendChild(Ref<ScrollingStateNode>&&);	238	void appendChild(Ref<ScrollingStateNode>&&);
		239	void insertChild(Ref<ScrollingStateNode>&&, size_t index);
		240
		241	size_t indexOfChild(ScrollingStateNode&) const;
239		242
240	String scrollingStateTreeAsText(ScrollingStateTreeAsTextBehavior = ScrollingStateTreeAsTextBehaviorNormal) const;	243	String scrollingStateTreeAsText(ScrollingStateTreeAsTextBehavior = ScrollingStateTreeAsTextBehaviorNormal) const;
241		244



    return ScrollingStateFixedNode::create(*this, nodeID);
}

bool ScrollingStateTree::nodeTypeAndParentMatch(ScrollingStateNode& node, ScrollingNodeType nodeType, ScrollingStateNode* parentNode) const
{
    if (node.nodeType() != nodeType)
        return false;

    return node.parent() == parentNode;
    if (!parent)
        return true;

    return node.parent() == parent;
}

ScrollingNodeID ScrollingStateTree::attachNode(ScrollingNodeType nodeType, ScrollingNodeID newNodeID, ScrollingNodeID parentID, size_t childIndex)
{
    ASSERT(newNodeID);

    if (auto* node = stateNodeForID(newNodeID)) {
        auto* parent = stateNodeForID(parentID);
        if (nodeTypeAndParentMatch(*node, nodeType, parent)) {
            if (!parentID)
                return newNodeID;

            size_t currentIndex = parent->indexOfChild(*node);
            if (currentIndex == childIndex)
                return newNodeID;

            ASSERT(currentIndex != notFound);
            Ref<ScrollingStateNode> protectedNode(*node);
            parent->children()->remove(currentIndex);

            if (childIndex == notFound)
                parent->appendChild(WTFMove(protectedNode));
            else
                parent->insertChild(WTFMove(protectedNode), childIndex);

            return newNodeID;
        }

#if ENABLE(ASYNC_SCROLLING)
        // If the type has changed, we need to destroy and recreate the node with a new ID.


    ScrollingStateNode* newNode = nullptr;
    if (!parentID) {
        ASSERT(!childIndex || childIndex == notFound);
        // If we're resetting the root node, we should clear the HashMap and destroy the current children.
        clear();


        m_hasNewRootStateNode = true;
    } else {
        auto* parent = stateNodeForID(parentID);
        if (!parent) {
            ASSERT_NOT_REACHED();
            return 0;
        }

        if (nodeType == SubframeScrollingNode && parentID) {
            if (auto orphanedNode = m_orphanedSubframeNodes.take(newNodeID)) {
                newNode = orphanedNode.get();
                if (childIndex == notFound)
                    parent->appendChild(orphanedNode.releaseNonNull());
                else
                    parent->insertChild(orphanedNode.releaseNonNull(), childIndex);
            }
        }

        if (!newNode) {
            auto stateNode = createNode(nodeType, newNodeID);
            newNode = stateNode.ptr();
            if (childIndex == notFound)
                parent->appendChild(WTFMove(stateNode));
            else
                parent->insertChild(WTFMove(stateNode), childIndex);
        }
    }

    addNode(*newNode);
    m_nodesRemovedSinceLastCommit.remove(newNodeID);
    return newNodeID;
}



    ScrollingStateFrameScrollingNode* rootStateNode() const { return m_rootStateNode.get(); }
    WEBCORE_EXPORT ScrollingStateNode* stateNodeForID(ScrollingNodeID) const;

    WEBCORE_EXPORT ScrollingNodeID attachNode(ScrollingNodeType, ScrollingNodeID, ScrollingNodeID parentID, size_t childIndex);
    void detachNode(ScrollingNodeID);
    void clear();
    


    Ref<ScrollingStateNode> createNode(ScrollingNodeType, ScrollingNodeID);

    bool nodeTypeAndParentMatch(ScrollingStateNode&, ScrollingNodeType, ScrollingStateNode* parentNode) const;

    enum class SubframeNodeRemoval { Delete, Orphan };
    void removeNodeAndAllDescendants(ScrollingStateNode*, SubframeNodeRemoval = SubframeNodeRemoval::Delete);



2018-12-06  Frederic Wang  <fwang@igalia.com>

        Allow control over child order when adding nodes to the scrolling tree
        https://bugs.webkit.org/show_bug.cgi?id=176914

        Reviewed by NOBODY (OOPS!).

        Based on an earlier patch by Simon Fraser.

        * Shared/RemoteLayerTree/RemoteScrollingCoordinatorTransaction.cpp:
        (WebKit::RemoteScrollingCoordinatorTransaction::decode): Make explicit that we want to append
        the new node at the end of child list.

2018-12-05  Ryosuke Niwa  <rniwa@webkit.org>

        REGRESSION(PSON): Process swapping code doesn't set DisplayID in WebContent process



        if (!decoder.decode(parentNodeID))
            return false;

        m_scrollingStateTree->attachNode(nodeType, nodeID, parentNodeID, notFound); // Append new node.
        ScrollingStateNode* newNode = m_scrollingStateTree->stateNodeForID(nodeID);
        ASSERT(newNode);
        ASSERT(!parentNodeID || newNode->parent());
- 

Return to Bug 176914

Lines 474-482 void AsyncScrollingCoordinator::scrollableAreaScrollbarLayerDidChange(Scrollable a/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp_sec1
- a/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp -3 / +3 lines
474	scrollableArea.horizontalScrollbarLayerDidChange();	474	scrollableArea.horizontalScrollbarLayerDidChange();
475	}	475	}
476		476
477	ScrollingNodeID AsyncScrollingCoordinator::attachToStateTree(ScrollingNodeType nodeType, ScrollingNodeID newNodeID, ScrollingNodeID parentID)	477	ScrollingNodeID AsyncScrollingCoordinator::attachToStateTree(ScrollingNodeType nodeType, ScrollingNodeID newNodeID, ScrollingNodeID parentID, size_t childIndex)
478	{	478	{
479	return m_scrollingStateTree->attachNode(nodeType, newNodeID, parentID);	479	return m_scrollingStateTree->attachNode(nodeType, newNodeID, parentID, childIndex);
480	}	480	}
481		481
482	void AsyncScrollingCoordinator::detachFromStateTree(ScrollingNodeID nodeID)	482	void AsyncScrollingCoordinator::detachFromStateTree(ScrollingNodeID nodeID)
Lines 509-515 void AsyncScrollingCoordinator::ensureRootStateNodeForFrameView(FrameView& frame a/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp_sec2
509	// For non-main frames, it is only possible to arrive in this function from	509	// For non-main frames, it is only possible to arrive in this function from
510	// RenderLayerCompositor::updateBacking where the node has already been created.	510	// RenderLayerCompositor::updateBacking where the node has already been created.
511	ASSERT(frameView.frame().isMainFrame());	511	ASSERT(frameView.frame().isMainFrame());
512	attachToStateTree(MainFrameScrollingNode, frameView.scrollLayerID(), 0);	512	attachToStateTree(MainFrameScrollingNode, frameView.scrollLayerID(), 0, 0);
513	}	513	}
514		514
515	void AsyncScrollingCoordinator::updateFrameScrollingNode(ScrollingNodeID nodeID, GraphicsLayer* layer, GraphicsLayer* scrolledContentsLayer, GraphicsLayer* counterScrollingLayer, GraphicsLayer* insetClipLayer, const ScrollingGeometry& scrollingGeometry)	515	void AsyncScrollingCoordinator::updateFrameScrollingNode(ScrollingNodeID nodeID, GraphicsLayer* layer, GraphicsLayer* scrolledContentsLayer, GraphicsLayer* counterScrollingLayer, GraphicsLayer* insetClipLayer, const ScrollingGeometry& scrollingGeometry)

Lines 164-170 public: a/Source/WebCore/page/scrolling/ScrollingCoordinator.h_sec1
- a/Source/WebCore/page/scrolling/ScrollingCoordinator.h -1 / +2 lines
164	virtual void commitTreeStateIfNeeded() { }	164	virtual void commitTreeStateIfNeeded() { }
165	virtual bool requestScrollPositionUpdate(FrameView&, const IntPoint&) { return false; }	165	virtual bool requestScrollPositionUpdate(FrameView&, const IntPoint&) { return false; }
166	virtual bool handleWheelEvent(FrameView&, const PlatformWheelEvent&) { return true; }	166	virtual bool handleWheelEvent(FrameView&, const PlatformWheelEvent&) { return true; }
167	virtual ScrollingNodeID attachToStateTree(ScrollingNodeType, ScrollingNodeID newNodeID, ScrollingNodeID /parentID/) { return newNodeID; }	167	virtual ScrollingNodeID attachToStateTree(ScrollingNodeType, ScrollingNodeID newNodeID, ScrollingNodeID /parentID/, size_t /childIndex/ = notFound) { return newNodeID; }
		168
168	virtual void detachFromStateTree(ScrollingNodeID) { }	169	virtual void detachFromStateTree(ScrollingNodeID) { }
169	virtual void clearStateTree() { }	170	virtual void clearStateTree() { }
170		171

Lines 82-106 Ref<ScrollingStateNode> ScrollingStateTree::createNode(ScrollingNodeType nodeTyp a/Source/WebCore/page/scrolling/ScrollingStateTree.cpp_sec1
- a/Source/WebCore/page/scrolling/ScrollingStateTree.cpp -12 / +35 lines
82	return ScrollingStateFixedNode::create(*this, nodeID);	82	return ScrollingStateFixedNode::create(*this, nodeID);
83	}	83	}
84		84
85	bool ScrollingStateTree::nodeTypeAndParentMatch(ScrollingStateNode& node, ScrollingNodeType nodeType, ScrollingNodeID parentID) const	85	bool ScrollingStateTree::nodeTypeAndParentMatch(ScrollingStateNode& node, ScrollingNodeType nodeType, ScrollingStateNode* parentNode) const
86	{	86	{
87	if (node.nodeType() != nodeType)	87	if (node.nodeType() != nodeType)
88	return false;	88	return false;
89		89
90	auto* parent = stateNodeForID(parentID);	90	return node.parent() == parentNode;
91	if (!parent)
92	return true;
93
94	return node.parent() == parent;
95	}	91	}
96		92
97	ScrollingNodeID ScrollingStateTree::attachNode(ScrollingNodeType nodeType, ScrollingNodeID newNodeID, ScrollingNodeID parentID)	93	ScrollingNodeID ScrollingStateTree::attachNode(ScrollingNodeType nodeType, ScrollingNodeID newNodeID, ScrollingNodeID parentID, size_t childIndex)
98	{	94	{
99	ASSERT(newNodeID);	95	ASSERT(newNodeID);
100		96
101	if (auto* node = stateNodeForID(newNodeID)) {	97	if (auto* node = stateNodeForID(newNodeID)) {
102	if (nodeTypeAndParentMatch(*node, nodeType, parentID))	98	auto* parent = stateNodeForID(parentID);
		99	if (nodeTypeAndParentMatch(*node, nodeType, parent)) {
		100	if (!parentID)
		101	return newNodeID;
		102
		103	size_t currentIndex = parent->indexOfChild(*node);
		104	if (currentIndex == childIndex)
		105	return newNodeID;
		106
		107	ASSERT(currentIndex != notFound);
		108	Ref<ScrollingStateNode> protectedNode(*node);
		109	parent->children()->remove(currentIndex);
		110
		111	if (childIndex == notFound)
		112	parent->appendChild(WTFMove(protectedNode));
		113	else
		114	parent->insertChild(WTFMove(protectedNode), childIndex);
		115
103	return newNodeID;	116	return newNodeID;
		117	}
104		118
105	#if ENABLE(ASYNC_SCROLLING)	119	#if ENABLE(ASYNC_SCROLLING)
106	// If the type has changed, we need to destroy and recreate the node with a new ID.	120	// If the type has changed, we need to destroy and recreate the node with a new ID.
Lines 114-119 ScrollingNodeID ScrollingStateTree::attachNode(ScrollingNodeType nodeType, Scrol a/Source/WebCore/page/scrolling/ScrollingStateTree.cpp_sec2
114		128
115	ScrollingStateNode* newNode = nullptr;	129	ScrollingStateNode* newNode = nullptr;
116	if (!parentID) {	130	if (!parentID) {
		131	ASSERT(!childIndex \|\| childIndex == notFound);
117	// If we're resetting the root node, we should clear the HashMap and destroy the current children.	132	// If we're resetting the root node, we should clear the HashMap and destroy the current children.
118	clear();	133	clear();
119		134
Lines 122-145 ScrollingNodeID ScrollingStateTree::attachNode(ScrollingNodeType nodeType, Scrol a/Source/WebCore/page/scrolling/ScrollingStateTree.cpp_sec3
122	m_hasNewRootStateNode = true;	137	m_hasNewRootStateNode = true;
123	} else {	138	} else {
124	auto* parent = stateNodeForID(parentID);	139	auto* parent = stateNodeForID(parentID);
125	if (!parent)	140	if (!parent) {
		141	ASSERT_NOT_REACHED();
126	return 0;	142	return 0;
		143	}
127		144
128	if (nodeType == SubframeScrollingNode && parentID) {	145	if (nodeType == SubframeScrollingNode && parentID) {
129	if (auto orphanedNode = m_orphanedSubframeNodes.take(newNodeID)) {	146	if (auto orphanedNode = m_orphanedSubframeNodes.take(newNodeID)) {
130	newNode = orphanedNode.get();	147	newNode = orphanedNode.get();
131	parent->appendChild(orphanedNode.releaseNonNull());	148	if (childIndex == notFound)
		149	parent->appendChild(orphanedNode.releaseNonNull());
		150	else
		151	parent->insertChild(orphanedNode.releaseNonNull(), childIndex);
132	}	152	}
133	}	153	}
134		154
135	if (!newNode) {	155	if (!newNode) {
136	auto stateNode = createNode(nodeType, newNodeID);	156	auto stateNode = createNode(nodeType, newNodeID);
137	newNode = stateNode.ptr();	157	newNode = stateNode.ptr();
138	parent->appendChild(WTFMove(stateNode));	158	if (childIndex == notFound)
		159	parent->appendChild(WTFMove(stateNode));
		160	else
		161	parent->insertChild(WTFMove(stateNode), childIndex);
139	}	162	}
140	}	163	}
141		164
142	m_stateNodeMap.set(newNodeID, newNode);	165	addNode(*newNode);
143	m_nodesRemovedSinceLastCommit.remove(newNodeID);	166	m_nodesRemovedSinceLastCommit.remove(newNodeID);
144	return newNodeID;	167	return newNodeID;
145	}	168	}

Lines 51-57 public: a/Source/WebCore/page/scrolling/ScrollingStateTree.h_sec1
- a/Source/WebCore/page/scrolling/ScrollingStateTree.h -2 / +2 lines
51	ScrollingStateFrameScrollingNode* rootStateNode() const { return m_rootStateNode.get(); }	51	ScrollingStateFrameScrollingNode* rootStateNode() const { return m_rootStateNode.get(); }
52	WEBCORE_EXPORT ScrollingStateNode* stateNodeForID(ScrollingNodeID) const;	52	WEBCORE_EXPORT ScrollingStateNode* stateNodeForID(ScrollingNodeID) const;
53		53
54	WEBCORE_EXPORT ScrollingNodeID attachNode(ScrollingNodeType, ScrollingNodeID, ScrollingNodeID parentID);	54	WEBCORE_EXPORT ScrollingNodeID attachNode(ScrollingNodeType, ScrollingNodeID, ScrollingNodeID parentID, size_t childIndex);
55	void detachNode(ScrollingNodeID);	55	void detachNode(ScrollingNodeID);
56	void clear();	56	void clear();
57		57
Lines 81-87 private: a/Source/WebCore/page/scrolling/ScrollingStateTree.h_sec2
81		81
82	Ref<ScrollingStateNode> createNode(ScrollingNodeType, ScrollingNodeID);	82	Ref<ScrollingStateNode> createNode(ScrollingNodeType, ScrollingNodeID);
83		83
84	bool nodeTypeAndParentMatch(ScrollingStateNode&, ScrollingNodeType, ScrollingNodeID parentID) const;	84	bool nodeTypeAndParentMatch(ScrollingStateNode&, ScrollingNodeType, ScrollingStateNode* parentNode) const;
85		85
86	enum class SubframeNodeRemoval { Delete, Orphan };	86	enum class SubframeNodeRemoval { Delete, Orphan };
87	void removeNodeAndAllDescendants(ScrollingStateNode*, SubframeNodeRemoval = SubframeNodeRemoval::Delete);	87	void removeNodeAndAllDescendants(ScrollingStateNode*, SubframeNodeRemoval = SubframeNodeRemoval::Delete);

Lines 413-419 bool RemoteScrollingCoordinatorTransaction::decode(IPC::Decoder& decoder) a/Source/WebKit/Shared/RemoteLayerTree/RemoteScrollingCoordinatorTransaction.cpp_sec1
- a/Source/WebKit/Shared/RemoteLayerTree/RemoteScrollingCoordinatorTransaction.cpp -2 / +1 lines
413	if (!decoder.decode(parentNodeID))	413	if (!decoder.decode(parentNodeID))
414	return false;	414	return false;
415		415
416	m_scrollingStateTree->attachNode(nodeType, nodeID, parentNodeID);	416	m_scrollingStateTree->attachNode(nodeType, nodeID, parentNodeID, notFound); // Append new node.
417	ScrollingStateNode* newNode = m_scrollingStateTree->stateNodeForID(nodeID);	417	ScrollingStateNode* newNode = m_scrollingStateTree->stateNodeForID(nodeID);
418	ASSERT(newNode);	418	ASSERT(newNode);
419	ASSERT(!parentNodeID \|\| newNode->parent());	419	ASSERT(!parentNodeID \|\| newNode->parent());
420	-

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +35 lines
		1	2018-12-06 Frederic Wang <fwang@igalia.com>
		2
		3	Allow control over child order when adding nodes to the scrolling tree
		4	https://bugs.webkit.org/show_bug.cgi?id=176914
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Based on an earlier patch by Simon Fraser.
		9
		10	Previously ScrollingCoordinator just allowed nodes to be "attached" with a given parent,
		11	but with no control over sibling order. To allow for correct hit-testing overflow and
		12	frame scrolling nodes, we have to build the scrolling tree in z-order.
		13
		14	This patch adds a 'childIndex' parameter to attachNode() which gives control over
		15	sibling order. For now, RenderLayerCompositor always uses the default 'notFound' value
		16	for childIndex so the current behavior (appending new nodes at the end of child list) is
		17	preserved.
		18
		19	No new tests, behavior unchanged and already covered by existing tests.
		20
		21	* page/scrolling/AsyncScrollingCoordinator.cpp:
		22	(WebCore::AsyncScrollingCoordinator::attachToStateTree):
		23	(WebCore::AsyncScrollingCoordinator::ensureRootStateNodeForFrameView):
		24	* page/scrolling/AsyncScrollingCoordinator.h:
		25	* page/scrolling/ScrollingCoordinator.h:
		26	(WebCore::ScrollingCoordinator::attachToStateTree):
		27	* page/scrolling/ScrollingStateNode.cpp:
		28	(WebCore::ScrollingStateNode::insertChild):
		29	(WebCore::ScrollingStateNode::indexOfChild const):
		30	* page/scrolling/ScrollingStateNode.h:
		31	* page/scrolling/ScrollingStateTree.cpp:
		32	(WebCore::ScrollingStateTree::nodeTypeAndParentMatch const):
		33	(WebCore::ScrollingStateTree::attachNode):
		34	* page/scrolling/ScrollingStateTree.h:
		35
1	2018-12-05 Don Olmstead <don.olmstead@sony.com>	36	2018-12-05 Don Olmstead <don.olmstead@sony.com>
2		37
3	[PlayStation] Enable WebCore	38	[PlayStation] Enable WebCore

Lines 97-102 void ScrollingStateNode::appendChild(Ref<ScrollingStateNode>&& childNode) a/Source/WebCore/page/scrolling/ScrollingStateNode.cpp_sec1
- a/Source/WebCore/page/scrolling/ScrollingStateNode.cpp +20 lines
97	m_children->append(WTFMove(childNode));	97	m_children->append(WTFMove(childNode));
98	}	98	}
99		99
		100	void ScrollingStateNode::insertChild(Ref<ScrollingStateNode>&& childNode, size_t index)
		101	{
		102	childNode->setParent(this);
		103
		104	if (!m_children) {
		105	ASSERT(!index);
		106	m_children = std::make_unique<Vector<RefPtr<ScrollingStateNode>>>();
		107	}
		108
		109	m_children->insert(index, WTFMove(childNode));
		110	}
		111
		112	size_t ScrollingStateNode::indexOfChild(ScrollingStateNode& childNode) const
		113	{
		114	if (!m_children)
		115	return notFound;
		116
		117	return m_children->find(&childNode);
		118	}
		119
100	void ScrollingStateNode::reconcileLayerPositionForViewportRect(const LayoutRect& viewportRect, ScrollingLayerPositionAction action)	120	void ScrollingStateNode::reconcileLayerPositionForViewportRect(const LayoutRect& viewportRect, ScrollingLayerPositionAction action)
101	{	121	{
102	if (!m_children)	122	if (!m_children)

Lines 1-3 a/Source/WebKit/ChangeLog_sec1
- a/Source/WebKit/ChangeLog +13 lines
		1	2018-12-06 Frederic Wang <fwang@igalia.com>
		2
		3	Allow control over child order when adding nodes to the scrolling tree
		4	https://bugs.webkit.org/show_bug.cgi?id=176914
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Based on an earlier patch by Simon Fraser.
		9
		10	* Shared/RemoteLayerTree/RemoteScrollingCoordinatorTransaction.cpp:
		11	(WebKit::RemoteScrollingCoordinatorTransaction::decode): Make explicit that we want to append
		12	the new node at the end of child list.
		13
1	2018-12-05 Ryosuke Niwa <rniwa@webkit.org>	14	2018-12-05 Ryosuke Niwa <rniwa@webkit.org>
2		15
3	REGRESSION(PSON): Process swapping code doesn't set DisplayID in WebContent process	16	REGRESSION(PSON): Process swapping code doesn't set DisplayID in WebContent process