Source/WebCore/page/scrolling/ScrollingStateTree.cpp - WebKit - Git at Google

 /*
  * Copyright (C) 2012 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  * THE POSSIBILITY OF SUCH DAMAGE.
  */

 #include "config.h"
 #include "ScrollingStateTree.h"

 #if ENABLE(ASYNC_SCROLLING) || USE(COORDINATED_GRAPHICS)

 #include "AsyncScrollingCoordinator.h"
 #include "Logging.h"
 #include "ScrollingStateFixedNode.h"
 #include "ScrollingStateFrameHostingNode.h"
 #include "ScrollingStateFrameScrollingNode.h"
 #include "ScrollingStateOverflowScrollingNode.h"
 #include "ScrollingStatePositionedNode.h"
 #include "ScrollingStateStickyNode.h"
 #include <wtf/text/CString.h>
 #include <wtf/text/TextStream.h>

 namespace WebCore {

 ScrollingStateTree::ScrollingStateTree(AsyncScrollingCoordinator* scrollingCoordinator)
     : m_scrollingCoordinator(scrollingCoordinator)
 {
 }

 ScrollingStateTree::~ScrollingStateTree() = default;

 void ScrollingStateTree::setHasChangedProperties(bool changedProperties)
 {
 #if ENABLE(ASYNC_SCROLLING)
     bool gainedChangedProperties = !m_hasChangedProperties && changedProperties;
 #endif

     m_hasChangedProperties = changedProperties;

 #if ENABLE(ASYNC_SCROLLING)
     if (gainedChangedProperties && m_scrollingCoordinator)
         m_scrollingCoordinator->scrollingStateTreePropertiesChanged();
 #endif
 }

 Ref<ScrollingStateNode> ScrollingStateTree::createNode(ScrollingNodeType nodeType, ScrollingNodeID nodeID)
 {
     switch (nodeType) {
     case ScrollingNodeType::MainFrame:
     case ScrollingNodeType::Subframe:
         return ScrollingStateFrameScrollingNode::create(*this, nodeType, nodeID);
     case ScrollingNodeType::FrameHosting:
         return ScrollingStateFrameHostingNode::create(*this, nodeID);
     case ScrollingNodeType::Overflow:
         return ScrollingStateOverflowScrollingNode::create(*this, nodeID);
     case ScrollingNodeType::Fixed:
         return ScrollingStateFixedNode::create(*this, nodeID);
     case ScrollingNodeType::Sticky:
         return ScrollingStateStickyNode::create(*this, nodeID);
     case ScrollingNodeType::Positioned:
         return ScrollingStatePositionedNode::create(*this, nodeID);
     }
     ASSERT_NOT_REACHED();
     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;
 }

 ScrollingNodeID ScrollingStateTree::createUnparentedNode(ScrollingNodeType nodeType, ScrollingNodeID newNodeID)
 {
     LOG_WITH_STREAM(Scrolling, stream << "ScrollingStateTree " << this << " createUnparentedNode " << newNodeID);

     if (auto* node = stateNodeForID(newNodeID)) {
         if (node->nodeType() == nodeType) {
             // If the node exists and is parented, unparent it. It may already be in m_unparentedNodes.
             unparentNode(newNodeID);
             return newNodeID;
         }

 #if ENABLE(ASYNC_SCROLLING)
         // If the type has changed, we need to destroy and recreate the node with a new ID.
         if (nodeType != node->nodeType()) {
             unparentChildrenAndDestroyNode(newNodeID);
             newNodeID = m_scrollingCoordinator->uniqueScrollingNodeID();
         }
 #endif
     }

     auto stateNode = createNode(nodeType, newNodeID);
     addNode(stateNode.get());
     m_unparentedNodes.add(newNodeID, WTFMove(stateNode));
     return newNodeID;
 }

 ScrollingNodeID ScrollingStateTree::insertNode(ScrollingNodeType nodeType, ScrollingNodeID newNodeID, ScrollingNodeID parentID, size_t childIndex)
 {
     LOG_WITH_STREAM(Scrolling, stream << "ScrollingStateTree " << this << " insertNode " << newNodeID << " in parent " << parentID << " at " << 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->removeChildAtIndex(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.
         if (nodeType != node->nodeType())
             newNodeID = m_scrollingCoordinator->uniqueScrollingNodeID();
 #endif

         // The node is being re-parented. To do that, we'll remove it, and then create a new node.
         unparentNode(newNodeID);
     }

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

         setRootStateNode(ScrollingStateFrameScrollingNode::create(*this, ScrollingNodeType::MainFrame, newNodeID));
         newNode = rootStateNode();
         m_hasNewRootStateNode = true;
     } else {
         auto* parent = stateNodeForID(parentID);
         if (!parent) {
             ASSERT_NOT_REACHED();
             return 0;
         }

         if (parentID) {
             if (auto unparentedNode = m_unparentedNodes.take(newNodeID)) {
                 LOG_WITH_STREAM(Scrolling, stream << "ScrollingStateTree " << this << " insertNode " << newNodeID << " getting node from unparented nodes");
                 newNode = unparentedNode.get();
                 nodeWasReattachedRecursive(*unparentedNode);

                 if (childIndex == notFound)
                     parent->appendChild(unparentedNode.releaseNonNull());
                 else
                     parent->insertChild(unparentedNode.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);
     return newNodeID;
 }

 void ScrollingStateTree::unparentNode(ScrollingNodeID nodeID)
 {
     if (!nodeID)
         return;

     LOG_WITH_STREAM(Scrolling, stream << "ScrollingStateTree " << this << " unparentNode " << nodeID);

     // The node may not be found if clear() was recently called.
     RefPtr<ScrollingStateNode> protectedNode = m_stateNodeMap.get(nodeID);
     if (!protectedNode)
         return;

     if (protectedNode == m_rootStateNode)
         m_rootStateNode = nullptr;

     protectedNode->removeFromParent();
     m_unparentedNodes.add(nodeID, WTFMove(protectedNode));
 }

 void ScrollingStateTree::unparentChildrenAndDestroyNode(ScrollingNodeID nodeID)
 {
     if (!nodeID)
         return;

     LOG_WITH_STREAM(Scrolling, stream << "ScrollingStateTree " << this << " unparentChildrenAndDestroyNode " << nodeID);

     // The node may not be found if clear() was recently called.
     RefPtr<ScrollingStateNode> protectedNode = m_stateNodeMap.take(nodeID);
     if (!protectedNode)
         return;

     if (protectedNode == m_rootStateNode)
         m_rootStateNode = nullptr;

     if (protectedNode->children()) {
         auto isolatedChildren = protectedNode->takeChildren();
         for (auto child : *isolatedChildren) {
             child->removeFromParent();
             LOG_WITH_STREAM(Scrolling, stream << " moving " << child->scrollingNodeID() << " to unparented nodes");
             m_unparentedNodes.add(child->scrollingNodeID(), WTFMove(child));
         }
     }

     protectedNode->removeFromParent();
     willRemoveNode(protectedNode.get());
 }

 void ScrollingStateTree::detachAndDestroySubtree(ScrollingNodeID nodeID)
 {
     if (!nodeID)
         return;

     LOG_WITH_STREAM(Scrolling, stream << "ScrollingStateTree " << this << " detachAndDestroySubtree " << nodeID);

     // The node may not be found if clear() was recently called.
     auto* node = m_stateNodeMap.take(nodeID);
     if (!node)
         return;

     // If the node was unparented, remove it from m_unparentedNodes (keeping it alive until this function returns).
     auto unparentedNode = m_unparentedNodes.take(nodeID);
     removeNodeAndAllDescendants(node);
 }

 void ScrollingStateTree::clear()
 {
     if (rootStateNode())
         removeNodeAndAllDescendants(rootStateNode());

     m_stateNodeMap.clear();
     m_unparentedNodes.clear();
 }

 void ScrollingStateTree::nodeWasReattachedRecursive(ScrollingStateNode& node)
 {
     // When a node is re-attached, the ScrollingTree is recreating the ScrollingNode from scratch, so we need to set all the dirty bits.
     node.setAllPropertiesChanged();

     if (auto* children = node.children()) {
         for (auto& child : *children)
             nodeWasReattachedRecursive(*child);
     }
 }

 std::unique_ptr<ScrollingStateTree> ScrollingStateTree::commit(LayerRepresentation::Type preferredLayerRepresentation)
 {
     if (!m_unparentedNodes.isEmpty()) {
         // We expect temporarily to have unparented nodes when committing when connecting across iframe boundaries, but unparented nodes should not stick around for a long time.
         LOG(Scrolling, "Committing with %u unparented nodes", m_unparentedNodes.size());
     }

     // This function clones and resets the current state tree, but leaves the tree structure intact.
     std::unique_ptr<ScrollingStateTree> treeStateClone = std::make_unique<ScrollingStateTree>();
     treeStateClone->setPreferredLayerRepresentation(preferredLayerRepresentation);

     if (m_rootStateNode)
         treeStateClone->setRootStateNode(static_reference_cast<ScrollingStateFrameScrollingNode>(m_rootStateNode->cloneAndReset(*treeStateClone)));

     // Now the clone tree has changed properties, and the original tree does not.
     treeStateClone->m_hasChangedProperties = m_hasChangedProperties;
     m_hasChangedProperties = false;

     treeStateClone->m_hasNewRootStateNode = m_hasNewRootStateNode;
     m_hasNewRootStateNode = false;

     return treeStateClone;
 }

 void ScrollingStateTree::setRootStateNode(Ref<ScrollingStateFrameScrollingNode>&& rootStateNode)
 {
     m_rootStateNode = WTFMove(rootStateNode);
 }

 void ScrollingStateTree::addNode(ScrollingStateNode& node)
 {
     m_stateNodeMap.add(node.scrollingNodeID(), &node);
 }

 void ScrollingStateTree::removeNodeAndAllDescendants(ScrollingStateNode* node)
 {
     auto* parent = node->parent();

     recursiveNodeWillBeRemoved(node);

     if (node == m_rootStateNode)
         m_rootStateNode = nullptr;
     else if (parent) {
         ASSERT(parent->children());
         ASSERT(parent->children()->find(node) != notFound);
         if (auto* children = parent->children()) {
             size_t index = children->find(node);
             if (index != notFound)
                 children->remove(index);
         }
     }
 }

 void ScrollingStateTree::recursiveNodeWillBeRemoved(ScrollingStateNode* currNode)
 {
     currNode->setParent(nullptr);
     willRemoveNode(currNode);

     if (auto* children = currNode->children()) {
         for (auto& child : *children)
             recursiveNodeWillBeRemoved(child.get());
     }
 }

 void ScrollingStateTree::willRemoveNode(ScrollingStateNode* node)
 {
     m_stateNodeMap.remove(node->scrollingNodeID());
     setHasChangedProperties();
 }

 ScrollingStateNode* ScrollingStateTree::stateNodeForID(ScrollingNodeID scrollLayerID) const
 {
     if (!scrollLayerID)
         return nullptr;

     auto it = m_stateNodeMap.find(scrollLayerID);
     if (it == m_stateNodeMap.end())
         return nullptr;

     ASSERT(it->value->scrollingNodeID() == scrollLayerID);
     return it->value;
 }

 void ScrollingStateTree::reconcileLayerPositionsRecursive(ScrollingStateNode& currNode, const LayoutRect& layoutViewport, ScrollingLayerPositionAction action)
 {
     currNode.reconcileLayerPositionForViewportRect(layoutViewport, action);

     if (!currNode.children())
         return;

     for (auto& child : *currNode.children()) {
         // Never need to cross frame boundaries, since viewport rect reconciliation is per frame.
         if (is<ScrollingStateFrameScrollingNode>(child))
             continue;

         reconcileLayerPositionsRecursive(*child, layoutViewport, action);
     }
 }

 void ScrollingStateTree::reconcileViewportConstrainedLayerPositions(ScrollingNodeID scrollingNodeID, const LayoutRect& layoutViewport, ScrollingLayerPositionAction action)
 {
     auto* scrollingNode = stateNodeForID(scrollingNodeID);
     if (!scrollingNode)
         return;

     reconcileLayerPositionsRecursive(*scrollingNode, layoutViewport, action);
 }

 } // namespace WebCore

 #ifndef NDEBUG
 void showScrollingStateTree(const WebCore::ScrollingStateTree* tree)
 {
     if (!tree)
         return;

     auto rootNode = tree->rootStateNode();
     if (!rootNode) {
         WTFLogAlways("Scrolling state tree %p with no root node\n", tree);
         return;
     }

     String output = rootNode->scrollingStateTreeAsText(WebCore::ScrollingStateTreeAsTextBehaviorDebug);
     WTFLogAlways("%s\n", output.utf8().data());
 }

 void showScrollingStateTree(const WebCore::ScrollingStateNode* node)
 {
     if (!node)
         return;

     showScrollingStateTree(&node->scrollingStateTree());
 }

 #endif

 #endif // ENABLE(ASYNC_SCROLLING) || USE(COORDINATED_GRAPHICS)
	/*
	* Copyright (C) 2012 Apple Inc. All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	*
	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
	* THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#include "config.h"
	#include "ScrollingStateTree.h"

	#if ENABLE(ASYNC_SCROLLING) \|\| USE(COORDINATED_GRAPHICS)

	#include "AsyncScrollingCoordinator.h"
	#include "Logging.h"
	#include "ScrollingStateFixedNode.h"
	#include "ScrollingStateFrameHostingNode.h"
	#include "ScrollingStateFrameScrollingNode.h"
	#include "ScrollingStateOverflowScrollingNode.h"
	#include "ScrollingStatePositionedNode.h"
	#include "ScrollingStateStickyNode.h"
	#include <wtf/text/CString.h>
	#include <wtf/text/TextStream.h>

	namespace WebCore {

	ScrollingStateTree::ScrollingStateTree(AsyncScrollingCoordinator* scrollingCoordinator)
	: m_scrollingCoordinator(scrollingCoordinator)
	{
	}

	ScrollingStateTree::~ScrollingStateTree() = default;

	void ScrollingStateTree::setHasChangedProperties(bool changedProperties)
	{
	#if ENABLE(ASYNC_SCROLLING)
	bool gainedChangedProperties = !m_hasChangedProperties && changedProperties;
	#endif

	m_hasChangedProperties = changedProperties;

	#if ENABLE(ASYNC_SCROLLING)
	if (gainedChangedProperties && m_scrollingCoordinator)
	m_scrollingCoordinator->scrollingStateTreePropertiesChanged();
	#endif
	}

	Ref<ScrollingStateNode> ScrollingStateTree::createNode(ScrollingNodeType nodeType, ScrollingNodeID nodeID)
	{
	switch (nodeType) {
	case ScrollingNodeType::MainFrame:
	case ScrollingNodeType::Subframe:
	return ScrollingStateFrameScrollingNode::create(*this, nodeType, nodeID);
	case ScrollingNodeType::FrameHosting:
	return ScrollingStateFrameHostingNode::create(*this, nodeID);
	case ScrollingNodeType::Overflow:
	return ScrollingStateOverflowScrollingNode::create(*this, nodeID);
	case ScrollingNodeType::Fixed:
	return ScrollingStateFixedNode::create(*this, nodeID);
	case ScrollingNodeType::Sticky:
	return ScrollingStateStickyNode::create(*this, nodeID);
	case ScrollingNodeType::Positioned:
	return ScrollingStatePositionedNode::create(*this, nodeID);
	}
	ASSERT_NOT_REACHED();
	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;
	}

	ScrollingNodeID ScrollingStateTree::createUnparentedNode(ScrollingNodeType nodeType, ScrollingNodeID newNodeID)
	{
	LOG_WITH_STREAM(Scrolling, stream << "ScrollingStateTree " << this << " createUnparentedNode " << newNodeID);

	if (auto* node = stateNodeForID(newNodeID)) {
	if (node->nodeType() == nodeType) {
	// If the node exists and is parented, unparent it. It may already be in m_unparentedNodes.
	unparentNode(newNodeID);
	return newNodeID;
	}

	#if ENABLE(ASYNC_SCROLLING)
	// If the type has changed, we need to destroy and recreate the node with a new ID.
	if (nodeType != node->nodeType()) {
	unparentChildrenAndDestroyNode(newNodeID);
	newNodeID = m_scrollingCoordinator->uniqueScrollingNodeID();
	}
	#endif
	}

	auto stateNode = createNode(nodeType, newNodeID);
	addNode(stateNode.get());
	m_unparentedNodes.add(newNodeID, WTFMove(stateNode));
	return newNodeID;
	}

	ScrollingNodeID ScrollingStateTree::insertNode(ScrollingNodeType nodeType, ScrollingNodeID newNodeID, ScrollingNodeID parentID, size_t childIndex)
	{
	LOG_WITH_STREAM(Scrolling, stream << "ScrollingStateTree " << this << " insertNode " << newNodeID << " in parent " << parentID << " at " << 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->removeChildAtIndex(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.
	if (nodeType != node->nodeType())
	newNodeID = m_scrollingCoordinator->uniqueScrollingNodeID();
	#endif

	// The node is being re-parented. To do that, we'll remove it, and then create a new node.
	unparentNode(newNodeID);
	}

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

	setRootStateNode(ScrollingStateFrameScrollingNode::create(*this, ScrollingNodeType::MainFrame, newNodeID));
	newNode = rootStateNode();
	m_hasNewRootStateNode = true;
	} else {
	auto* parent = stateNodeForID(parentID);
	if (!parent) {
	ASSERT_NOT_REACHED();
	return 0;
	}

	if (parentID) {
	if (auto unparentedNode = m_unparentedNodes.take(newNodeID)) {
	LOG_WITH_STREAM(Scrolling, stream << "ScrollingStateTree " << this << " insertNode " << newNodeID << " getting node from unparented nodes");
	newNode = unparentedNode.get();
	nodeWasReattachedRecursive(*unparentedNode);

	if (childIndex == notFound)
	parent->appendChild(unparentedNode.releaseNonNull());
	else
	parent->insertChild(unparentedNode.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);
	return newNodeID;
	}

	void ScrollingStateTree::unparentNode(ScrollingNodeID nodeID)
	{
	if (!nodeID)
	return;

	LOG_WITH_STREAM(Scrolling, stream << "ScrollingStateTree " << this << " unparentNode " << nodeID);

	// The node may not be found if clear() was recently called.
	RefPtr<ScrollingStateNode> protectedNode = m_stateNodeMap.get(nodeID);
	if (!protectedNode)
	return;

	if (protectedNode == m_rootStateNode)
	m_rootStateNode = nullptr;

	protectedNode->removeFromParent();
	m_unparentedNodes.add(nodeID, WTFMove(protectedNode));
	}

	void ScrollingStateTree::unparentChildrenAndDestroyNode(ScrollingNodeID nodeID)
	{
	if (!nodeID)
	return;

	LOG_WITH_STREAM(Scrolling, stream << "ScrollingStateTree " << this << " unparentChildrenAndDestroyNode " << nodeID);

	// The node may not be found if clear() was recently called.
	RefPtr<ScrollingStateNode> protectedNode = m_stateNodeMap.take(nodeID);
	if (!protectedNode)
	return;

	if (protectedNode == m_rootStateNode)
	m_rootStateNode = nullptr;

	if (protectedNode->children()) {
	auto isolatedChildren = protectedNode->takeChildren();
	for (auto child : *isolatedChildren) {
	child->removeFromParent();
	LOG_WITH_STREAM(Scrolling, stream << " moving " << child->scrollingNodeID() << " to unparented nodes");
	m_unparentedNodes.add(child->scrollingNodeID(), WTFMove(child));
	}
	}

	protectedNode->removeFromParent();
	willRemoveNode(protectedNode.get());
	}

	void ScrollingStateTree::detachAndDestroySubtree(ScrollingNodeID nodeID)
	{
	if (!nodeID)
	return;

	LOG_WITH_STREAM(Scrolling, stream << "ScrollingStateTree " << this << " detachAndDestroySubtree " << nodeID);

	// The node may not be found if clear() was recently called.
	auto* node = m_stateNodeMap.take(nodeID);
	if (!node)
	return;

	// If the node was unparented, remove it from m_unparentedNodes (keeping it alive until this function returns).
	auto unparentedNode = m_unparentedNodes.take(nodeID);
	removeNodeAndAllDescendants(node);
	}

	void ScrollingStateTree::clear()
	{
	if (rootStateNode())
	removeNodeAndAllDescendants(rootStateNode());

	m_stateNodeMap.clear();
	m_unparentedNodes.clear();
	}

	void ScrollingStateTree::nodeWasReattachedRecursive(ScrollingStateNode& node)
	{
	// When a node is re-attached, the ScrollingTree is recreating the ScrollingNode from scratch, so we need to set all the dirty bits.
	node.setAllPropertiesChanged();

	if (auto* children = node.children()) {
	for (auto& child : *children)
	nodeWasReattachedRecursive(*child);
	}
	}

	std::unique_ptr<ScrollingStateTree> ScrollingStateTree::commit(LayerRepresentation::Type preferredLayerRepresentation)
	{
	if (!m_unparentedNodes.isEmpty()) {
	// We expect temporarily to have unparented nodes when committing when connecting across iframe boundaries, but unparented nodes should not stick around for a long time.
	LOG(Scrolling, "Committing with %u unparented nodes", m_unparentedNodes.size());
	}

	// This function clones and resets the current state tree, but leaves the tree structure intact.
	std::unique_ptr<ScrollingStateTree> treeStateClone = std::make_unique<ScrollingStateTree>();
	treeStateClone->setPreferredLayerRepresentation(preferredLayerRepresentation);

	if (m_rootStateNode)
	treeStateClone->setRootStateNode(static_reference_cast<ScrollingStateFrameScrollingNode>(m_rootStateNode->cloneAndReset(*treeStateClone)));

	// Now the clone tree has changed properties, and the original tree does not.
	treeStateClone->m_hasChangedProperties = m_hasChangedProperties;
	m_hasChangedProperties = false;

	treeStateClone->m_hasNewRootStateNode = m_hasNewRootStateNode;
	m_hasNewRootStateNode = false;

	return treeStateClone;
	}

	void ScrollingStateTree::setRootStateNode(Ref<ScrollingStateFrameScrollingNode>&& rootStateNode)
	{
	m_rootStateNode = WTFMove(rootStateNode);
	}

	void ScrollingStateTree::addNode(ScrollingStateNode& node)
	{
	m_stateNodeMap.add(node.scrollingNodeID(), &node);
	}

	void ScrollingStateTree::removeNodeAndAllDescendants(ScrollingStateNode* node)
	{
	auto* parent = node->parent();

	recursiveNodeWillBeRemoved(node);

	if (node == m_rootStateNode)
	m_rootStateNode = nullptr;
	else if (parent) {
	ASSERT(parent->children());
	ASSERT(parent->children()->find(node) != notFound);
	if (auto* children = parent->children()) {
	size_t index = children->find(node);
	if (index != notFound)
	children->remove(index);
	}
	}
	}

	void ScrollingStateTree::recursiveNodeWillBeRemoved(ScrollingStateNode* currNode)
	{
	currNode->setParent(nullptr);
	willRemoveNode(currNode);

	if (auto* children = currNode->children()) {
	for (auto& child : *children)
	recursiveNodeWillBeRemoved(child.get());
	}
	}

	void ScrollingStateTree::willRemoveNode(ScrollingStateNode* node)
	{
	m_stateNodeMap.remove(node->scrollingNodeID());
	setHasChangedProperties();
	}

	ScrollingStateNode* ScrollingStateTree::stateNodeForID(ScrollingNodeID scrollLayerID) const
	{
	if (!scrollLayerID)
	return nullptr;

	auto it = m_stateNodeMap.find(scrollLayerID);
	if (it == m_stateNodeMap.end())
	return nullptr;

	ASSERT(it->value->scrollingNodeID() == scrollLayerID);
	return it->value;
	}

	void ScrollingStateTree::reconcileLayerPositionsRecursive(ScrollingStateNode& currNode, const LayoutRect& layoutViewport, ScrollingLayerPositionAction action)
	{
	currNode.reconcileLayerPositionForViewportRect(layoutViewport, action);

	if (!currNode.children())
	return;

	for (auto& child : *currNode.children()) {
	// Never need to cross frame boundaries, since viewport rect reconciliation is per frame.
	if (is<ScrollingStateFrameScrollingNode>(child))
	continue;

	reconcileLayerPositionsRecursive(*child, layoutViewport, action);
	}
	}

	void ScrollingStateTree::reconcileViewportConstrainedLayerPositions(ScrollingNodeID scrollingNodeID, const LayoutRect& layoutViewport, ScrollingLayerPositionAction action)
	{
	auto* scrollingNode = stateNodeForID(scrollingNodeID);
	if (!scrollingNode)
	return;

	reconcileLayerPositionsRecursive(*scrollingNode, layoutViewport, action);
	}

	} // namespace WebCore

	#ifndef NDEBUG
	void showScrollingStateTree(const WebCore::ScrollingStateTree* tree)
	{
	if (!tree)
	return;

	auto rootNode = tree->rootStateNode();
	if (!rootNode) {
	WTFLogAlways("Scrolling state tree %p with no root node\n", tree);
	return;
	}

	String output = rootNode->scrollingStateTreeAsText(WebCore::ScrollingStateTreeAsTextBehaviorDebug);
	WTFLogAlways("%s\n", output.utf8().data());
	}

	void showScrollingStateTree(const WebCore::ScrollingStateNode* node)
	{
	if (!node)
	return;

	showScrollingStateTree(&node->scrollingStateTree());
	}

	#endif

	#endif // ENABLE(ASYNC_SCROLLING) \|\| USE(COORDINATED_GRAPHICS)