Attachment #359466 for bug #193539

View Details Raw Unified Return to Bug 193539

| Differences between



2019-01-18  Antti Koivisto  <antti@apple.com>

        Implement asynchronous frame scrolling for iOS
        https://bugs.webkit.org/show_bug.cgi?id=193539
        <rdar://problem/47379873>

        Reviewed by NOBODY (OOPS!).

        This patch implements UIScrollView based frame scrolling on iOS, enabled by the "Async Frame Scrolling"
        internal setting (still off by default).

        * page/scrolling/ios/ScrollingTreeFrameScrollingNodeIOS.h:
        (WebCore::ScrollingTreeFrameScrollingNodeIOS::scrollLayer const): Deleted.
        * page/scrolling/ios/ScrollingTreeFrameScrollingNodeIOS.mm:
        (WebCore::ScrollingTreeFrameScrollingNodeIOS::setScrollPosition):

        Export ScrollingTreeFrameScrollingNodeIOS.

        * rendering/RenderLayerCompositor.cpp:
        (WebCore::RenderLayerCompositor::visibleRectForLayerFlushing const):
        (WebCore::RenderLayerCompositor::frameViewDidChangeSize):
        (WebCore::RenderLayerCompositor::updateScrollLayerClipping):

        If we don't have a separate clip layer, just resize and position the scroll layer.

        (WebCore::RenderLayerCompositor::updateRootLayerPosition):
        (WebCore::RenderLayerCompositor::updateOverflowControlsLayers):
        (WebCore::RenderLayerCompositor::ensureRootLayer):

        Use GraphicsLayer::Type::Scrolling as the scroll layer type when async frame scrolling is enabled.
        Don't create a separate clip layer since the scroll layer will handle clipping.

        * rendering/RenderLayerCompositor.h:

2019-01-16  Simon Fraser  <simon.fraser@apple.com>

        Stub out scrolling tree classes for overflow scrolling nodes on macOS




namespace WebCore {

class WEBCORE_EXPORT ScrollingTreeFrameScrollingNodeIOS : public ScrollingTreeFrameScrollingNode {
public:
    static Ref<ScrollingTreeFrameScrollingNodeIOS> create(ScrollingTree&, ScrollingNodeType, ScrollingNodeID);
    virtual ~ScrollingTreeFrameScrollingNodeIOS();

protected:

    void updateLayersAfterDelegatedScroll(const FloatPoint&) override;
    void updateLayersAfterAncestorChange(const ScrollingTreeNode& changedNode, const FloatRect& fixedPositionRect, const FloatSize& cumulativeDelta) override;

    void setScrollPosition(const FloatPoint&) override;
    void setScrollLayerPosition(const FloatPoint&, const FloatRect& layoutViewport) override;

    FloatPoint minimumScrollPosition() const override;
    FloatPoint maximumScrollPosition() const override;

protected:
    void updateChildNodesAfterScroll(const FloatPoint&);
    CALayer *scrollLayer() const { return m_scrollLayer.get(); }
    void updateChildNodesAfterScroll(const FloatPoint&);

private:
    RetainPtr<CALayer> m_scrollLayer;
    RetainPtr<CALayer> m_counterScrollingLayer;
    RetainPtr<CALayer> m_headerLayer;

Lines 104-109 FloatPoint ScrollingTreeFrameScrollingNo Source/WebCore/page/scrolling/ios/ScrollingTreeFrameScrollingNodeIOS.mm_sec1
- Source/WebCore/page/scrolling/ios/ScrollingTreeFrameScrollingNodeIOS.mm +5 lines
104	return -m_scrollLayer.get().position;	104	return -m_scrollLayer.get().position;
105	}	105	}
106		106
		107	void ScrollingTreeFrameScrollingNodeIOS::setScrollPosition(const FloatPoint& scrollPosition)
		108	{
		109	ScrollingTreeFrameScrollingNode::setScrollPosition(scrollPosition);
		110	}
		111
107	void ScrollingTreeFrameScrollingNodeIOS::setScrollPositionWithoutContentEdgeConstraints(const FloatPoint& scrollPosition)	112	void ScrollingTreeFrameScrollingNodeIOS::setScrollPositionWithoutContentEdgeConstraints(const FloatPoint& scrollPosition)
108	{	113	{
109	if (shouldUpdateScrollLayerPositionSynchronously()) {	114	if (shouldUpdateScrollLayerPositionSynchronously()) {



#if PLATFORM(IOS_FAMILY)
    return frameView.exposedContentRect();
#else
    // Having a m_scrollLayer indicates that we're doing scrolling via GraphicsLayers.
    FloatRect visibleRect = m_scrollLayer ? FloatRect({ }, frameView.sizeForVisibleContent()) : frameView.visibleContentRect();

    if (frameView.viewExposedRect())
        visibleRect.intersect(frameView.viewExposedRect().value());

    if (auto* layer = m_renderView.layer())
        layer->setNeedsCompositingGeometryUpdate();

    if (m_scrollLayer) {
        updateScrollLayerClipping();
        m_clipLayer->setSize(frameView.sizeForVisibleContent());
        m_clipLayer->setPosition(positionForClipLayer());

        frameViewDidScroll();
        updateOverflowControlsLayers();

#if ENABLE(RUBBER_BANDING)
        if (m_layerForOverhangAreas) {
            auto& frameView = m_renderView.frameView();
            m_layerForOverhangAreas->setSize(frameView.frameRect().size());
            m_layerForOverhangAreas->setPosition(FloatPoint(0, frameView.topContentInset()));
        }
#endif
    }

        fixedBackgroundLayer->setPosition(frameView.scrollPositionForFixedPosition());
}

void RenderLayerCompositor::updateScrollLayerClipping()
{
    auto* layerForClipping = this->layerForClipping();
    if (!layerForClipping)
        return;

    layerForClipping->setSize(m_renderView.frameView().sizeForVisibleContent());
    layerForClipping->setPosition(positionForClipLayer());
}

FloatPoint RenderLayerCompositor::positionForClipLayer() const
{
    auto& frameView = m_renderView.frameView();

        m_rootContentLayer->setPosition(m_renderView.frameView().positionForRootContentLayer());
        m_rootContentLayer->setAnchorPoint(FloatPoint3D());
    }

    updateScrollLayerClipping();
        m_clipLayer->setPosition(positionForClipLayer());
    }

#if ENABLE(RUBBER_BANDING)
    if (m_contentShadowLayer && m_rootContentLayer) {


            // We want the overhang areas layer to be positioned below the frame contents,
            // so insert it below the clip layer.
            m_overflowControlsHostLayer->addChildBelow(*m_layerForOverhangAreas, layerForClipping());
        }
    } else
        GraphicsLayer::unparentAndClear(m_layerForOverhangAreas);

            m_overflowControlsHostLayer = GraphicsLayer::create(graphicsLayerFactory(), *this);
            m_overflowControlsHostLayer->setName("overflow controls host");

            auto scrollLayerType = GraphicsLayer::Type::Normal;
#if PLATFORM(IOS)
            if (m_renderView.settings().asyncFrameScrollingEnabled())
                scrollLayerType = GraphicsLayer::Type::Scrolling;
#endif
            m_scrollLayer = GraphicsLayer::create(graphicsLayerFactory(), *this, scrollLayerType);
            m_scrollLayer->setName("frame scrolling");

            if (scrollLayerType == GraphicsLayer::Type::Scrolling) {
                // Scroll layer clips so there is no need for a separate clipping layer.
                m_overflowControlsHostLayer->addChild(*m_scrollLayer);
            } else {
                m_clipLayer = GraphicsLayer::create(graphicsLayerFactory(), *this);
                m_clipLayer->setName("frame clipping");
                m_clipLayer->setMasksToBounds(true);
                m_clipLayer->setAnchorPoint(FloatPoint3D());

                m_clipLayer->addChild(*m_scrollLayer);
                m_overflowControlsHostLayer->addChild(*m_clipLayer);
            }

            m_scrollLayer->addChild(*m_rootContentLayer);

            updateScrollLayerClipping();
            updateOverflowControlsLayers();

            if (hasCoordinatedScrolling())



    GraphicsLayer* clipLayer() const { return m_clipLayer.get(); }
    GraphicsLayer* rootContentLayer() const { return m_rootContentLayer.get(); }

    GraphicsLayer* layerForClipping() const {  return m_clipLayer ? m_clipLayer.get() : m_scrollLayer.get();  }

#if ENABLE(RUBBER_BANDING)
    GraphicsLayer* headerLayer() const { return m_layerForHeader.get(); }

    void updateOverflowControlsLayers();

    void updateScrollLayerPosition();
    void updateScrollLayerClipping();

    FloatPoint positionForClipLayer() const;




2019-01-18  Antti Koivisto  <antti@apple.com>

        Implement asynchronous frame scrolling for iOS
        https://bugs.webkit.org/show_bug.cgi?id=193539
        <rdar://problem/47379873>

        Reviewed by NOBODY (OOPS!).

        Add a scrolling node type that can handle UIScrollView backed frames.
        It basically just instantiates and forwards to the existing ScrollingTreeScrollingNodeDelegateIOS.

        * UIProcess/RemoteLayerTree/RemoteScrollingTree.cpp:
        (WebKit::RemoteScrollingTree::createScrollingTreeNode):
        * UIProcess/RemoteLayerTree/ios/RemoteScrollingCoordinatorProxyIOS.mm:
        (WebKit::RemoteScrollingCoordinatorProxy::connectStateNodeLayers):
        * UIProcess/RemoteLayerTree/ios/ScrollingTreeFrameScrollingNodeRemoteIOS.h: Added.
        * UIProcess/RemoteLayerTree/ios/ScrollingTreeFrameScrollingNodeRemoteIOS.mm: Added.
        (WebKit::ScrollingTreeFrameScrollingNodeRemoteIOS::create):
        (WebKit::ScrollingTreeFrameScrollingNodeRemoteIOS::ScrollingTreeFrameScrollingNodeRemoteIOS):
        (WebKit::ScrollingTreeFrameScrollingNodeRemoteIOS::~ScrollingTreeFrameScrollingNodeRemoteIOS):
        (WebKit::ScrollingTreeFrameScrollingNodeRemoteIOS::commitStateBeforeChildren):
        (WebKit::ScrollingTreeFrameScrollingNodeRemoteIOS::commitStateAfterChildren):
        (WebKit::ScrollingTreeFrameScrollingNodeRemoteIOS::updateLayersAfterAncestorChange):
        (WebKit::ScrollingTreeFrameScrollingNodeRemoteIOS::scrollPosition const):
        (WebKit::ScrollingTreeFrameScrollingNodeRemoteIOS::setScrollLayerPosition):
        (WebKit::ScrollingTreeFrameScrollingNodeRemoteIOS::updateLayersAfterDelegatedScroll):
        * WebKit.xcodeproj/project.pbxproj:

2019-01-17  Wenson Hsieh  <wenson_hsieh@apple.com>

        [iOS] Content offset jumps erratically when autoscrolling near scroll view content inset areas

Lines 454-459 UIProcess/RemoteLayerTree/mac/ScrollingT Source/WebKit/SourcesCocoa.txt_sec1
- Source/WebKit/SourcesCocoa.txt +1 lines
454		454
455	UIProcess/RemoteLayerTree/ios/RemoteLayerTreeHostIOS.mm	455	UIProcess/RemoteLayerTree/ios/RemoteLayerTreeHostIOS.mm
456	UIProcess/RemoteLayerTree/ios/RemoteScrollingCoordinatorProxyIOS.mm	456	UIProcess/RemoteLayerTree/ios/RemoteScrollingCoordinatorProxyIOS.mm
		457	UIProcess/RemoteLayerTree/ios/ScrollingTreeFrameScrollingNodeRemoteIOS.mm
457	UIProcess/RemoteLayerTree/ios/ScrollingTreeOverflowScrollingNodeIOS.mm	458	UIProcess/RemoteLayerTree/ios/ScrollingTreeOverflowScrollingNodeIOS.mm
458	UIProcess/RemoteLayerTree/ios/ScrollingTreeScrollingNodeDelegateIOS.mm	459	UIProcess/RemoteLayerTree/ios/ScrollingTreeScrollingNodeDelegateIOS.mm
459		460



#include <WebCore/ScrollingTreeStickyNode.h>

#if PLATFORM(IOS_FAMILY)
#include "ScrollingTreeFrameScrollingNodeRemoteIOS.h"
#include "ScrollingTreeOverflowScrollingNodeIOS.h"
#include <WebCore/ScrollingTreeFrameScrollingNodeIOS.h>
#else

    case ScrollingNodeType::MainFrame:
    case ScrollingNodeType::Subframe:
#if PLATFORM(IOS_FAMILY)
        return ScrollingTreeFrameScrollingNodeRemoteIOS::create(*this, nodeType, nodeID);
#else
        return ScrollingTreeFrameScrollingNodeRemoteMac::create(*this, nodeType, nodeID);
#endif

Lines 68-73 void RemoteScrollingCoordinatorProxy::co Source/WebKit/UIProcess/RemoteLayerTree/ios/RemoteScrollingCoordinatorProxyIOS.mm_sec1
- Source/WebKit/UIProcess/RemoteLayerTree/ios/RemoteScrollingCoordinatorProxyIOS.mm +3 lines
68	if (scrollingStateNode.hasChangedProperty(ScrollingStateNode::ScrollLayer))	68	if (scrollingStateNode.hasChangedProperty(ScrollingStateNode::ScrollLayer))
69	scrollingStateNode.setLayer(layerTreeHost.layerForID(scrollingStateNode.layer()));	69	scrollingStateNode.setLayer(layerTreeHost.layerForID(scrollingStateNode.layer()));
70		70
		71	if (scrollingStateNode.hasChangedProperty(ScrollingStateScrollingNode::ScrolledContentsLayer))
		72	scrollingStateNode.setScrolledContentsLayer(layerTreeHost.layerForID(scrollingStateNode.scrolledContentsLayer()));
		73
71	if (scrollingStateNode.hasChangedProperty(ScrollingStateFrameScrollingNode::CounterScrollingLayer))	74	if (scrollingStateNode.hasChangedProperty(ScrollingStateFrameScrollingNode::CounterScrollingLayer))
72	scrollingStateNode.setCounterScrollingLayer(layerTreeHost.layerForID(scrollingStateNode.counterScrollingLayer()));	75	scrollingStateNode.setCounterScrollingLayer(layerTreeHost.layerForID(scrollingStateNode.counterScrollingLayer()));
73		76



/*
 * Copyright (C) 2019 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.
 */

#pragma once

#if ENABLE(ASYNC_SCROLLING) && PLATFORM(IOS_FAMILY)

#include <WebCore/ScrollingTreeFrameScrollingNodeIOS.h>

namespace WebKit {

class ScrollingTreeScrollingNodeDelegateIOS;

class ScrollingTreeFrameScrollingNodeRemoteIOS : public WebCore::ScrollingTreeFrameScrollingNodeIOS {
public:
    static Ref<ScrollingTreeFrameScrollingNodeRemoteIOS> create(WebCore::ScrollingTree&, WebCore::ScrollingNodeType, WebCore::ScrollingNodeID);
    virtual ~ScrollingTreeFrameScrollingNodeRemoteIOS();

private:
    ScrollingTreeFrameScrollingNodeRemoteIOS(WebCore::ScrollingTree&, WebCore::ScrollingNodeType, WebCore::ScrollingNodeID);

    void commitStateBeforeChildren(const WebCore::ScrollingStateNode&) override;
    void commitStateAfterChildren(const WebCore::ScrollingStateNode&) override;

    WebCore::FloatPoint scrollPosition() const override;

    void setScrollLayerPosition(const WebCore::FloatPoint&, const WebCore::FloatRect& layoutViewport) override;

    void updateLayersAfterViewportChange(const WebCore::FloatRect& fixedPositionRect, double scale) override { }
    void updateLayersAfterDelegatedScroll(const WebCore::FloatPoint& scrollPosition) override;

    void updateLayersAfterAncestorChange(const WebCore::ScrollingTreeNode& changedNode, const WebCore::FloatRect& fixedPositionRect, const WebCore::FloatSize& cumulativeDelta) override;

    std::unique_ptr<ScrollingTreeScrollingNodeDelegateIOS> m_scrollingNodeDelegate;
};

} // namespace WebKit

#endif // ENABLE(ASYNC_SCROLLING) && PLATFORM(IOS_FAMILY)



/*
 * Copyright (C) 2019 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.
 */

#import "config.h"
#import "ScrollingTreeFrameScrollingNodeRemoteIOS.h"

#if PLATFORM(IOS_FAMILY) && ENABLE(ASYNC_SCROLLING)

#import "ScrollingTreeScrollingNodeDelegateIOS.h"
#import <WebCore/ScrollingStateScrollingNode.h>

namespace WebKit {
using namespace WebCore;

Ref<ScrollingTreeFrameScrollingNodeRemoteIOS> ScrollingTreeFrameScrollingNodeRemoteIOS::create(ScrollingTree& scrollingTree, ScrollingNodeType nodeType, ScrollingNodeID nodeID)
{
    return adoptRef(*new ScrollingTreeFrameScrollingNodeRemoteIOS(scrollingTree, nodeType, nodeID));
}

ScrollingTreeFrameScrollingNodeRemoteIOS::ScrollingTreeFrameScrollingNodeRemoteIOS(ScrollingTree& scrollingTree, ScrollingNodeType nodeType, ScrollingNodeID nodeID)
    : ScrollingTreeFrameScrollingNodeIOS(scrollingTree, nodeType, nodeID)
{
}

ScrollingTreeFrameScrollingNodeRemoteIOS::~ScrollingTreeFrameScrollingNodeRemoteIOS()
{
}

void ScrollingTreeFrameScrollingNodeRemoteIOS::commitStateBeforeChildren(const ScrollingStateNode& stateNode)
{
    ScrollingTreeFrameScrollingNodeIOS::commitStateBeforeChildren(stateNode);

    if (stateNode.hasChangedProperty(ScrollingStateScrollingNode::ScrollLayer)) {
        if (scrollLayer() && [[scrollLayer() delegate] isKindOfClass:[UIScrollView self]])
            m_scrollingNodeDelegate = std::make_unique<ScrollingTreeScrollingNodeDelegateIOS>(*this);
        else
            m_scrollingNodeDelegate = nullptr;
    }

    if (m_scrollingNodeDelegate)
        m_scrollingNodeDelegate->commitStateBeforeChildren(downcast<ScrollingStateScrollingNode>(stateNode));
}

void ScrollingTreeFrameScrollingNodeRemoteIOS::commitStateAfterChildren(const ScrollingStateNode& stateNode)
{
    ScrollingTreeFrameScrollingNodeIOS::commitStateAfterChildren(stateNode);

    if (m_scrollingNodeDelegate)
        m_scrollingNodeDelegate->commitStateAfterChildren(downcast<ScrollingStateScrollingNode>(stateNode));
}

void ScrollingTreeFrameScrollingNodeRemoteIOS::updateLayersAfterAncestorChange(const ScrollingTreeNode& changedNode, const FloatRect& fixedPositionRect, const FloatSize& cumulativeDelta)
{
    if (m_scrollingNodeDelegate) {
        m_scrollingNodeDelegate->updateLayersAfterAncestorChange(changedNode, fixedPositionRect, cumulativeDelta);
        return;
    }
    ScrollingTreeFrameScrollingNodeIOS::updateLayersAfterAncestorChange(changedNode, fixedPositionRect, cumulativeDelta);
}

FloatPoint ScrollingTreeFrameScrollingNodeRemoteIOS::scrollPosition() const
{
    if (m_scrollingNodeDelegate)
        return m_scrollingNodeDelegate->scrollPosition();

    return ScrollingTreeFrameScrollingNodeIOS::scrollPosition();
}

void ScrollingTreeFrameScrollingNodeRemoteIOS::setScrollLayerPosition(const FloatPoint& scrollPosition, const FloatRect& layoutViewport)
{
    if (m_scrollingNodeDelegate) {
        m_scrollingNodeDelegate->setScrollLayerPosition(scrollPosition);
        return;
    }
    ScrollingTreeFrameScrollingNodeIOS::setScrollLayerPosition(scrollPosition, layoutViewport);
}

void ScrollingTreeFrameScrollingNodeRemoteIOS::updateLayersAfterDelegatedScroll(const FloatPoint& scrollPosition)
{
    if (m_scrollingNodeDelegate) {
        m_scrollingNodeDelegate->updateChildNodesAfterScroll(scrollPosition);
        return;
    }
    ScrollingTreeFrameScrollingNodeIOS::updateLayersAfterDelegatedScroll(scrollPosition);
}

}

#endif

Return to Bug 193539

Lines 447-454 FloatRect RenderLayerCompositor::visible Source/WebCore/rendering/RenderLayerCompositor.cpp_sec1
- Source/WebCore/rendering/RenderLayerCompositor.cpp -26 / +39 lines
447	#if PLATFORM(IOS_FAMILY)	447	#if PLATFORM(IOS_FAMILY)
448	return frameView.exposedContentRect();	448	return frameView.exposedContentRect();
449	#else	449	#else
450	// Having a m_clipLayer indicates that we're doing scrolling via GraphicsLayers.	450	// Having a m_scrollLayer indicates that we're doing scrolling via GraphicsLayers.
451	FloatRect visibleRect = m_clipLayer ? FloatRect({ }, frameView.sizeForVisibleContent()) : frameView.visibleContentRect();	451	FloatRect visibleRect = m_scrollLayer ? FloatRect({ }, frameView.sizeForVisibleContent()) : frameView.visibleContentRect();
452		452
453	if (frameView.viewExposedRect())	453	if (frameView.viewExposedRect())
454	visibleRect.intersect(frameView.viewExposedRect().value());	454	visibleRect.intersect(frameView.viewExposedRect().value());
Lines 1786-1803 void RenderLayerCompositor::frameViewDid Source/WebCore/rendering/RenderLayerCompositor.cpp_sec2
1786	if (auto* layer = m_renderView.layer())	1786	if (auto* layer = m_renderView.layer())
1787	layer->setNeedsCompositingGeometryUpdate();	1787	layer->setNeedsCompositingGeometryUpdate();
1788		1788
1789	if (m_clipLayer) {	1789	if (m_scrollLayer) {
1790	const FrameView& frameView = m_renderView.frameView();	1790	updateScrollLayerClipping();
1791	m_clipLayer->setSize(frameView.sizeForVisibleContent());
1792	m_clipLayer->setPosition(positionForClipLayer());
1793
1794	frameViewDidScroll();	1791	frameViewDidScroll();
1795	updateOverflowControlsLayers();	1792	updateOverflowControlsLayers();
1796		1793
1797	#if ENABLE(RUBBER_BANDING)	1794	#if ENABLE(RUBBER_BANDING)
1798	if (m_layerForOverhangAreas) {	1795	if (m_layerForOverhangAreas) {
		1796	auto& frameView = m_renderView.frameView();
1799	m_layerForOverhangAreas->setSize(frameView.frameRect().size());	1797	m_layerForOverhangAreas->setSize(frameView.frameRect().size());
1800	m_layerForOverhangAreas->setPosition(FloatPoint(0, m_renderView.frameView().topContentInset()));	1798	m_layerForOverhangAreas->setPosition(FloatPoint(0, frameView.topContentInset()));
1801	}	1799	}
1802	#endif	1800	#endif
1803	}	1801	}
Lines 1822-1827 void RenderLayerCompositor::updateScroll Source/WebCore/rendering/RenderLayerCompositor.cpp_sec3
1822	fixedBackgroundLayer->setPosition(frameView.scrollPositionForFixedPosition());	1820	fixedBackgroundLayer->setPosition(frameView.scrollPositionForFixedPosition());
1823	}	1821	}
1824		1822
		1823	void RenderLayerCompositor::updateScrollLayerClipping()
		1824	{
		1825	auto* layerForClipping = this->layerForClipping();
		1826	if (!layerForClipping)
		1827	return;
		1828
		1829	layerForClipping->setSize(m_renderView.frameView().sizeForVisibleContent());
		1830	layerForClipping->setPosition(positionForClipLayer());
		1831	}
		1832
1825	FloatPoint RenderLayerCompositor::positionForClipLayer() const	1833	FloatPoint RenderLayerCompositor::positionForClipLayer() const
1826	{	1834	{
1827	auto& frameView = m_renderView.frameView();	1835	auto& frameView = m_renderView.frameView();
Lines 2057-2066 void RenderLayerCompositor::updateRootLa Source/WebCore/rendering/RenderLayerCompositor.cpp_sec4
2057	m_rootContentLayer->setPosition(m_renderView.frameView().positionForRootContentLayer());	2065	m_rootContentLayer->setPosition(m_renderView.frameView().positionForRootContentLayer());
2058	m_rootContentLayer->setAnchorPoint(FloatPoint3D());	2066	m_rootContentLayer->setAnchorPoint(FloatPoint3D());
2059	}	2067	}
2060	if (m_clipLayer) {	2068
2061	m_clipLayer->setSize(m_renderView.frameView().sizeForVisibleContent());	2069	updateScrollLayerClipping();
2062	m_clipLayer->setPosition(positionForClipLayer());
2063	}
2064		2070
2065	#if ENABLE(RUBBER_BANDING)	2071	#if ENABLE(RUBBER_BANDING)
2066	if (m_contentShadowLayer && m_rootContentLayer) {	2072	if (m_contentShadowLayer && m_rootContentLayer) {
Lines 3293-3299 void RenderLayerCompositor::updateOverfl Source/WebCore/rendering/RenderLayerCompositor.cpp_sec5
3293		3299
3294	// We want the overhang areas layer to be positioned below the frame contents,	3300	// We want the overhang areas layer to be positioned below the frame contents,
3295	// so insert it below the clip layer.	3301	// so insert it below the clip layer.
3296	m_overflowControlsHostLayer->addChildBelow(*m_layerForOverhangAreas, m_clipLayer.get());	3302	m_overflowControlsHostLayer->addChildBelow(*m_layerForOverhangAreas, layerForClipping());
3297	}	3303	}
3298	} else	3304	} else
3299	GraphicsLayer::unparentAndClear(m_layerForOverhangAreas);	3305	GraphicsLayer::unparentAndClear(m_layerForOverhangAreas);
Lines 3405-3427 void RenderLayerCompositor::ensureRootLa Source/WebCore/rendering/RenderLayerCompositor.cpp_sec6
3405	m_overflowControlsHostLayer = GraphicsLayer::create(graphicsLayerFactory(), *this);	3411	m_overflowControlsHostLayer = GraphicsLayer::create(graphicsLayerFactory(), *this);
3406	m_overflowControlsHostLayer->setName("overflow controls host");	3412	m_overflowControlsHostLayer->setName("overflow controls host");
3407		3413
3408	// Create a clipping layer if this is an iframe	3414	auto scrollLayerType = GraphicsLayer::Type::Normal;
3409	m_clipLayer = GraphicsLayer::create(graphicsLayerFactory(), *this);	3415	#if PLATFORM(IOS)
3410	m_clipLayer->setName("frame clipping");	3416	if (m_renderView.settings().asyncFrameScrollingEnabled())
3411	m_clipLayer->setMasksToBounds(true);	3417	scrollLayerType = GraphicsLayer::Type::Scrolling;
3412		3418	#endif
3413	m_scrollLayer = GraphicsLayer::create(graphicsLayerFactory(), *this);	3419	m_scrollLayer = GraphicsLayer::create(graphicsLayerFactory(), *this, scrollLayerType);
3414	m_scrollLayer->setName("frame scrolling");	3420	m_scrollLayer->setName("frame scrolling");
3415		3421
3416	// Hook them up	3422	if (scrollLayerType == GraphicsLayer::Type::Scrolling) {
3417	m_overflowControlsHostLayer->addChild(*m_clipLayer);	3423	// Scroll layer clips so there is no need for a separate clipping layer.
3418	m_clipLayer->addChild(*m_scrollLayer);	3424	m_overflowControlsHostLayer->addChild(*m_scrollLayer);
3419	m_scrollLayer->addChild(*m_rootContentLayer);	3425	} else {
		3426	m_clipLayer = GraphicsLayer::create(graphicsLayerFactory(), *this);
		3427	m_clipLayer->setName("frame clipping");
		3428	m_clipLayer->setMasksToBounds(true);
		3429	m_clipLayer->setAnchorPoint(FloatPoint3D());
3420		3430
3421	m_clipLayer->setSize(m_renderView.frameView().sizeForVisibleContent());	3431	m_clipLayer->addChild(*m_scrollLayer);
3422	m_clipLayer->setPosition(positionForClipLayer());	3432	m_overflowControlsHostLayer->addChild(*m_clipLayer);
3423	m_clipLayer->setAnchorPoint(FloatPoint3D());	3433	}
		3434
		3435	m_scrollLayer->addChild(*m_rootContentLayer);
3424		3436
		3437	updateScrollLayerClipping();
3425	updateOverflowControlsLayers();	3438	updateOverflowControlsLayers();
3426		3439
3427	if (hasCoordinatedScrolling())	3440	if (hasCoordinatedScrolling())

Lines 236-241 public: Source/WebCore/rendering/RenderLayerCompositor.h_sec1
- Source/WebCore/rendering/RenderLayerCompositor.h +2 lines
236	GraphicsLayer* clipLayer() const { return m_clipLayer.get(); }	236	GraphicsLayer* clipLayer() const { return m_clipLayer.get(); }
237	GraphicsLayer* rootContentLayer() const { return m_rootContentLayer.get(); }	237	GraphicsLayer* rootContentLayer() const { return m_rootContentLayer.get(); }
238		238
		239	GraphicsLayer* layerForClipping() const { return m_clipLayer ? m_clipLayer.get() : m_scrollLayer.get(); }
239		240
240	#if ENABLE(RUBBER_BANDING)	241	#if ENABLE(RUBBER_BANDING)
241	GraphicsLayer* headerLayer() const { return m_layerForHeader.get(); }	242	GraphicsLayer* headerLayer() const { return m_layerForHeader.get(); }
Lines 433-438 private: Source/WebCore/rendering/RenderLayerCompositor.h_sec2
433	void updateOverflowControlsLayers();	434	void updateOverflowControlsLayers();
434		435
435	void updateScrollLayerPosition();	436	void updateScrollLayerPosition();
		437	void updateScrollLayerClipping();
436		438
437	FloatPoint positionForClipLayer() const;	439	FloatPoint positionForClipLayer() const;
438		440

Lines 1-3 Source/WebCore/ChangeLog_sec1
- Source/WebCore/ChangeLog +34 lines
		1	2019-01-18 Antti Koivisto <antti@apple.com>
		2
		3	Implement asynchronous frame scrolling for iOS
		4	https://bugs.webkit.org/show_bug.cgi?id=193539
		5	<rdar://problem/47379873>
		6
		7	Reviewed by NOBODY (OOPS!).
		8
		9	This patch implements UIScrollView based frame scrolling on iOS, enabled by the "Async Frame Scrolling"
		10	internal setting (still off by default).
		11
		12	* page/scrolling/ios/ScrollingTreeFrameScrollingNodeIOS.h:
		13	(WebCore::ScrollingTreeFrameScrollingNodeIOS::scrollLayer const): Deleted.
		14	* page/scrolling/ios/ScrollingTreeFrameScrollingNodeIOS.mm:
		15	(WebCore::ScrollingTreeFrameScrollingNodeIOS::setScrollPosition):
		16
		17	Export ScrollingTreeFrameScrollingNodeIOS.
		18
		19	* rendering/RenderLayerCompositor.cpp:
		20	(WebCore::RenderLayerCompositor::visibleRectForLayerFlushing const):
		21	(WebCore::RenderLayerCompositor::frameViewDidChangeSize):
		22	(WebCore::RenderLayerCompositor::updateScrollLayerClipping):
		23
		24	If we don't have a separate clip layer, just resize and position the scroll layer.
		25
		26	(WebCore::RenderLayerCompositor::updateRootLayerPosition):
		27	(WebCore::RenderLayerCompositor::updateOverflowControlsLayers):
		28	(WebCore::RenderLayerCompositor::ensureRootLayer):
		29
		30	Use GraphicsLayer::Type::Scrolling as the scroll layer type when async frame scrolling is enabled.
		31	Don't create a separate clip layer since the scroll layer will handle clipping.
		32
		33	* rendering/RenderLayerCompositor.h:
		34
1	2019-01-16 Simon Fraser <simon.fraser@apple.com>	35	2019-01-16 Simon Fraser <simon.fraser@apple.com>
2		36
3	Stub out scrolling tree classes for overflow scrolling nodes on macOS	37	Stub out scrolling tree classes for overflow scrolling nodes on macOS

Lines 34-42 OBJC_CLASS CALayer; Source/WebCore/page/scrolling/ios/ScrollingTreeFrameScrollingNodeIOS.h_sec1
- Source/WebCore/page/scrolling/ios/ScrollingTreeFrameScrollingNodeIOS.h -4 / +6 lines
34		34
35	namespace WebCore {	35	namespace WebCore {
36		36
37	class ScrollingTreeFrameScrollingNodeIOS : public ScrollingTreeFrameScrollingNode {	37	class WEBCORE_EXPORT ScrollingTreeFrameScrollingNodeIOS : public ScrollingTreeFrameScrollingNode {
38	public:	38	public:
39	WEBCORE_EXPORT static Ref<ScrollingTreeFrameScrollingNodeIOS> create(ScrollingTree&, ScrollingNodeType, ScrollingNodeID);	39	static Ref<ScrollingTreeFrameScrollingNodeIOS> create(ScrollingTree&, ScrollingNodeType, ScrollingNodeID);
40	virtual ~ScrollingTreeFrameScrollingNodeIOS();	40	virtual ~ScrollingTreeFrameScrollingNodeIOS();
41		41
42	protected:	42	protected:
Lines 55-69 protected: Source/WebCore/page/scrolling/ios/ScrollingTreeFrameScrollingNodeIOS.h_sec2
55	void updateLayersAfterDelegatedScroll(const FloatPoint&) override;	55	void updateLayersAfterDelegatedScroll(const FloatPoint&) override;
56	void updateLayersAfterAncestorChange(const ScrollingTreeNode& changedNode, const FloatRect& fixedPositionRect, const FloatSize& cumulativeDelta) override;	56	void updateLayersAfterAncestorChange(const ScrollingTreeNode& changedNode, const FloatRect& fixedPositionRect, const FloatSize& cumulativeDelta) override;
57		57
		58	void setScrollPosition(const FloatPoint&) override;
58	void setScrollLayerPosition(const FloatPoint&, const FloatRect& layoutViewport) override;	59	void setScrollLayerPosition(const FloatPoint&, const FloatRect& layoutViewport) override;
59		60
60	FloatPoint minimumScrollPosition() const override;	61	FloatPoint minimumScrollPosition() const override;
61	FloatPoint maximumScrollPosition() const override;	62	FloatPoint maximumScrollPosition() const override;
62		63
63	private:	64	protected:
64	void updateChildNodesAfterScroll(const FloatPoint&);
65	CALayer *scrollLayer() const { return m_scrollLayer.get(); }	65	CALayer *scrollLayer() const { return m_scrollLayer.get(); }
		66	void updateChildNodesAfterScroll(const FloatPoint&);
66		67
		68	private:
67	RetainPtr<CALayer> m_scrollLayer;	69	RetainPtr<CALayer> m_scrollLayer;
68	RetainPtr<CALayer> m_counterScrollingLayer;	70	RetainPtr<CALayer> m_counterScrollingLayer;
69	RetainPtr<CALayer> m_headerLayer;	71	RetainPtr<CALayer> m_headerLayer;

Lines 1-3 Source/WebKit/ChangeLog_sec1
- Source/WebKit/ChangeLog +28 lines
		1	2019-01-18 Antti Koivisto <antti@apple.com>
		2
		3	Implement asynchronous frame scrolling for iOS
		4	https://bugs.webkit.org/show_bug.cgi?id=193539
		5	<rdar://problem/47379873>
		6
		7	Reviewed by NOBODY (OOPS!).
		8
		9	Add a scrolling node type that can handle UIScrollView backed frames.
		10	It basically just instantiates and forwards to the existing ScrollingTreeScrollingNodeDelegateIOS.
		11
		12	* UIProcess/RemoteLayerTree/RemoteScrollingTree.cpp:
		13	(WebKit::RemoteScrollingTree::createScrollingTreeNode):
		14	* UIProcess/RemoteLayerTree/ios/RemoteScrollingCoordinatorProxyIOS.mm:
		15	(WebKit::RemoteScrollingCoordinatorProxy::connectStateNodeLayers):
		16	* UIProcess/RemoteLayerTree/ios/ScrollingTreeFrameScrollingNodeRemoteIOS.h: Added.
		17	* UIProcess/RemoteLayerTree/ios/ScrollingTreeFrameScrollingNodeRemoteIOS.mm: Added.
		18	(WebKit::ScrollingTreeFrameScrollingNodeRemoteIOS::create):
		19	(WebKit::ScrollingTreeFrameScrollingNodeRemoteIOS::ScrollingTreeFrameScrollingNodeRemoteIOS):
		20	(WebKit::ScrollingTreeFrameScrollingNodeRemoteIOS::~ScrollingTreeFrameScrollingNodeRemoteIOS):
		21	(WebKit::ScrollingTreeFrameScrollingNodeRemoteIOS::commitStateBeforeChildren):
		22	(WebKit::ScrollingTreeFrameScrollingNodeRemoteIOS::commitStateAfterChildren):
		23	(WebKit::ScrollingTreeFrameScrollingNodeRemoteIOS::updateLayersAfterAncestorChange):
		24	(WebKit::ScrollingTreeFrameScrollingNodeRemoteIOS::scrollPosition const):
		25	(WebKit::ScrollingTreeFrameScrollingNodeRemoteIOS::setScrollLayerPosition):
		26	(WebKit::ScrollingTreeFrameScrollingNodeRemoteIOS::updateLayersAfterDelegatedScroll):
		27	* WebKit.xcodeproj/project.pbxproj:
		28
1	2019-01-17 Wenson Hsieh <wenson_hsieh@apple.com>	29	2019-01-17 Wenson Hsieh <wenson_hsieh@apple.com>
2		30
3	[iOS] Content offset jumps erratically when autoscrolling near scroll view content inset areas	31	[iOS] Content offset jumps erratically when autoscrolling near scroll view content inset areas

Lines 34-39 Source/WebKit/UIProcess/RemoteLayerTree/RemoteScrollingTree.cpp_sec1
- Source/WebKit/UIProcess/RemoteLayerTree/RemoteScrollingTree.cpp -1 / +2 lines
34	#include <WebCore/ScrollingTreeStickyNode.h>	34	#include <WebCore/ScrollingTreeStickyNode.h>
35		35
36	#if PLATFORM(IOS_FAMILY)	36	#if PLATFORM(IOS_FAMILY)
		37	#include "ScrollingTreeFrameScrollingNodeRemoteIOS.h"
37	#include "ScrollingTreeOverflowScrollingNodeIOS.h"	38	#include "ScrollingTreeOverflowScrollingNodeIOS.h"
38	#include <WebCore/ScrollingTreeFrameScrollingNodeIOS.h>	39	#include <WebCore/ScrollingTreeFrameScrollingNodeIOS.h>
39	#else	40	#else
Lines 115-121 Ref<ScrollingTreeNode> RemoteScrollingTr Source/WebKit/UIProcess/RemoteLayerTree/RemoteScrollingTree.cpp_sec2
115	case ScrollingNodeType::MainFrame:	116	case ScrollingNodeType::MainFrame:
116	case ScrollingNodeType::Subframe:	117	case ScrollingNodeType::Subframe:
117	#if PLATFORM(IOS_FAMILY)	118	#if PLATFORM(IOS_FAMILY)
118	return ScrollingTreeFrameScrollingNodeIOS::create(*this, nodeType, nodeID);	119	return ScrollingTreeFrameScrollingNodeRemoteIOS::create(*this, nodeType, nodeID);
119	#else	120	#else
120	return ScrollingTreeFrameScrollingNodeRemoteMac::create(*this, nodeType, nodeID);	121	return ScrollingTreeFrameScrollingNodeRemoteMac::create(*this, nodeType, nodeID);
121	#endif	122	#endif

Line 0 Source/WebKit/UIProcess/RemoteLayerTree/ios/ScrollingTreeFrameScrollingNodeRemoteIOS.h_sec1
- Source/WebKit/UIProcess/RemoteLayerTree/ios/ScrollingTreeFrameScrollingNodeRemoteIOS.h +61 lines
	1	/*
	2	* Copyright (C) 2019 Apple Inc. All rights reserved.
	3	*
	4	* Redistribution and use in source and binary forms, with or without
	5	* modification, are permitted provided that the following conditions
	6	* are met:
	7	* 1. Redistributions of source code must retain the above copyright
	8	* notice, this list of conditions and the following disclaimer.
	9	* 2. Redistributions in binary form must reproduce the above copyright
	10	* notice, this list of conditions and the following disclaimer in the
	11	* documentation and/or other materials provided with the distribution.
	12	*
	13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
	14	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
	15	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
	17	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	18	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	19	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	20	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	21	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	22	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
	23	* THE POSSIBILITY OF SUCH DAMAGE.
	24	*/
	25
	26	#pragma once
	27
	28	#if ENABLE(ASYNC_SCROLLING) && PLATFORM(IOS_FAMILY)
	29
	30	#include <WebCore/ScrollingTreeFrameScrollingNodeIOS.h>
	31
	32	namespace WebKit {
	33
	34	class ScrollingTreeScrollingNodeDelegateIOS;
	35
	36	class ScrollingTreeFrameScrollingNodeRemoteIOS : public WebCore::ScrollingTreeFrameScrollingNodeIOS {
	37	public:
	38	static Ref<ScrollingTreeFrameScrollingNodeRemoteIOS> create(WebCore::ScrollingTree&, WebCore::ScrollingNodeType, WebCore::ScrollingNodeID);
	39	virtual ~ScrollingTreeFrameScrollingNodeRemoteIOS();
	40
	41	private:
	42	ScrollingTreeFrameScrollingNodeRemoteIOS(WebCore::ScrollingTree&, WebCore::ScrollingNodeType, WebCore::ScrollingNodeID);
	43
	44	void commitStateBeforeChildren(const WebCore::ScrollingStateNode&) override;
	45	void commitStateAfterChildren(const WebCore::ScrollingStateNode&) override;
	46
	47	WebCore::FloatPoint scrollPosition() const override;
	48
	49	void setScrollLayerPosition(const WebCore::FloatPoint&, const WebCore::FloatRect& layoutViewport) override;
	50
	51	void updateLayersAfterViewportChange(const WebCore::FloatRect& fixedPositionRect, double scale) override { }
	52	void updateLayersAfterDelegatedScroll(const WebCore::FloatPoint& scrollPosition) override;
	53
	54	void updateLayersAfterAncestorChange(const WebCore::ScrollingTreeNode& changedNode, const WebCore::FloatRect& fixedPositionRect, const WebCore::FloatSize& cumulativeDelta) override;
	55
	56	std::unique_ptr<ScrollingTreeScrollingNodeDelegateIOS> m_scrollingNodeDelegate;
	57	};
	58
	59	} // namespace WebKit
	60
	61	#endif // ENABLE(ASYNC_SCROLLING) && PLATFORM(IOS_FAMILY)

Lines 1593-1598 Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec1
- Source/WebKit/WebKit.xcodeproj/project.pbxproj -2 / +6 lines
1593	E4436ECF1A0D040B00EAD204 /* NetworkCacheStorage.h in Headers / = {isa = PBXBuildFile; fileRef = E4436EC21A0CFDB200EAD204 / NetworkCacheStorage.h */; };	1593	E4436ECF1A0D040B00EAD204 /* NetworkCacheStorage.h in Headers / = {isa = PBXBuildFile; fileRef = E4436EC21A0CFDB200EAD204 / NetworkCacheStorage.h */; };
1594	E489D28C1A0A2DB80078C06A /* NetworkCacheCoders.h in Headers / = {isa = PBXBuildFile; fileRef = E489D2851A0A2DB80078C06A / NetworkCacheCoders.h */; };	1594	E489D28C1A0A2DB80078C06A /* NetworkCacheCoders.h in Headers / = {isa = PBXBuildFile; fileRef = E489D2851A0A2DB80078C06A / NetworkCacheCoders.h */; };
1595	E49D40D71AD3FB170066B7B9 /* NetworkCacheBlobStorage.h in Headers / = {isa = PBXBuildFile; fileRef = E49D40D61AD3FB170066B7B9 / NetworkCacheBlobStorage.h */; };	1595	E49D40D71AD3FB170066B7B9 /* NetworkCacheBlobStorage.h in Headers / = {isa = PBXBuildFile; fileRef = E49D40D61AD3FB170066B7B9 / NetworkCacheBlobStorage.h */; };
		1596	E4D54D0421F1D72D007E3C36 /* ScrollingTreeFrameScrollingNodeRemoteIOS.h in Headers / = {isa = PBXBuildFile; fileRef = E40C1F9321F0B96E00530718 / ScrollingTreeFrameScrollingNodeRemoteIOS.h */; };
1596	E4E57F6B21A83B1200345F3C /* RemoteLayerTreeNode.h in Headers / = {isa = PBXBuildFile; fileRef = E4E57F6A21A83B1100345F3C / RemoteLayerTreeNode.h */; };	1597	E4E57F6B21A83B1200345F3C /* RemoteLayerTreeNode.h in Headers / = {isa = PBXBuildFile; fileRef = E4E57F6A21A83B1100345F3C / RemoteLayerTreeNode.h */; };
1597	E4E864931B16750700C82F40 /* VersionChecks.h in Headers / = {isa = PBXBuildFile; fileRef = E4E8648E1B1673FB00C82F40 / VersionChecks.h */; };	1598	E4E864931B16750700C82F40 /* VersionChecks.h in Headers / = {isa = PBXBuildFile; fileRef = E4E8648E1B1673FB00C82F40 / VersionChecks.h */; };
1598	E52CF55220A35C3A00DADA27 /* WebDataListSuggestionPicker.h in Headers / = {isa = PBXBuildFile; fileRef = E52CF55020A35C3A00DADA27 / WebDataListSuggestionPicker.h */; };	1599	E52CF55220A35C3A00DADA27 /* WebDataListSuggestionPicker.h in Headers / = {isa = PBXBuildFile; fileRef = E52CF55020A35C3A00DADA27 / WebDataListSuggestionPicker.h */; };
Lines 4441-4446 Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec2
4441	E404907321DE65F70037F0DB /* ScrollingTreeFrameScrollingNodeRemoteMac.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollingTreeFrameScrollingNodeRemoteMac.h; sourceTree = "<group>"; };	4442	E404907321DE65F70037F0DB /* ScrollingTreeFrameScrollingNodeRemoteMac.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollingTreeFrameScrollingNodeRemoteMac.h; sourceTree = "<group>"; };
4442	E404907421DE65F70037F0DB /* ScrollerMac.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = ScrollerMac.mm; sourceTree = "<group>"; };	4443	E404907421DE65F70037F0DB /* ScrollerMac.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = ScrollerMac.mm; sourceTree = "<group>"; };
4443	E404907521DE65F70037F0DB /* ScrollerMac.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollerMac.h; sourceTree = "<group>"; };	4444	E404907521DE65F70037F0DB /* ScrollerMac.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollerMac.h; sourceTree = "<group>"; };
		4445	E40C1F9321F0B96E00530718 /* ScrollingTreeFrameScrollingNodeRemoteIOS.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollingTreeFrameScrollingNodeRemoteIOS.h; sourceTree = "<group>"; };
		4446	E40C1F9521F0B97F00530718 /* ScrollingTreeFrameScrollingNodeRemoteIOS.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = ScrollingTreeFrameScrollingNodeRemoteIOS.mm; sourceTree = "<group>"; };
4444	E413F59B1AC1ADB600345360 /* NetworkCacheEntry.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NetworkCacheEntry.h; sourceTree = "<group>"; };	4447	E413F59B1AC1ADB600345360 /* NetworkCacheEntry.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NetworkCacheEntry.h; sourceTree = "<group>"; };
4445	E413F59E1AC1AF9D00345360 /* NetworkCacheEntry.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = NetworkCacheEntry.cpp; sourceTree = "<group>"; };	4448	E413F59E1AC1AF9D00345360 /* NetworkCacheEntry.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = NetworkCacheEntry.cpp; sourceTree = "<group>"; };
4446	E42E060B1AA7440D00B11699 /* NetworkCacheIOChannel.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NetworkCacheIOChannel.h; sourceTree = "<group>"; };	4449	E42E060B1AA7440D00B11699 /* NetworkCacheIOChannel.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NetworkCacheIOChannel.h; sourceTree = "<group>"; };
Lines 4844-4850 Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec3
4844	1A53C2A51A32569F004E8C70 /* WebsiteDataStore.h */,	4847	1A53C2A51A32569F004E8C70 /* WebsiteDataStore.h */,
4845	5C46C0AC21B7198B00BC5991 /* WebsiteDataStoreConfiguration.cpp */,	4848	5C46C0AC21B7198B00BC5991 /* WebsiteDataStoreConfiguration.cpp */,
4846	5C46C0AD21B7198C00BC5991 /* WebsiteDataStoreConfiguration.h */,	4849	5C46C0AD21B7198C00BC5991 /* WebsiteDataStoreConfiguration.h */,
4847	4118DC1B21E6D11A00DE04C7 /* WebsiteDataStoreQuotaManager.h */,
4848	);	4850	);
4849	path = WebsiteData;	4851	path = WebsiteData;
4850	sourceTree = "<group>";	4852	sourceTree = "<group>";
Lines 5513-5518 Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec4
5513	2DC18FB1218A6E9E0025A88D /* RemoteLayerTreeViews.h */,	5515	2DC18FB1218A6E9E0025A88D /* RemoteLayerTreeViews.h */,
5514	2DC18FB2218A6E9E0025A88D /* RemoteLayerTreeViews.mm */,	5516	2DC18FB2218A6E9E0025A88D /* RemoteLayerTreeViews.mm */,
5515	0F0C365B18C05CA100F607D7 /* RemoteScrollingCoordinatorProxyIOS.mm */,	5517	0F0C365B18C05CA100F607D7 /* RemoteScrollingCoordinatorProxyIOS.mm */,
		5518	E40C1F9321F0B96E00530718 /* ScrollingTreeFrameScrollingNodeRemoteIOS.h */,
		5519	E40C1F9521F0B97F00530718 /* ScrollingTreeFrameScrollingNodeRemoteIOS.mm */,
5516	0F931C1A18C5711900DBA7C3 /* ScrollingTreeOverflowScrollingNodeIOS.h */,	5520	0F931C1A18C5711900DBA7C3 /* ScrollingTreeOverflowScrollingNodeIOS.h */,
5517	0F931C1B18C5711900DBA7C3 /* ScrollingTreeOverflowScrollingNodeIOS.mm */,	5521	0F931C1B18C5711900DBA7C3 /* ScrollingTreeOverflowScrollingNodeIOS.mm */,
5518	0F931C1A18C5711900DBB8D4 /* ScrollingTreeScrollingNodeDelegateIOS.h */,	5522	0F931C1A18C5711900DBB8D4 /* ScrollingTreeScrollingNodeDelegateIOS.h */,
Lines 8852-8857 Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec5
8852	1A81B38118BD66AD0007FDAC /* _WKVisitedLinkStore.h in Headers */,	8856	1A81B38118BD66AD0007FDAC /* _WKVisitedLinkStore.h in Headers */,
8853	1A81B38518BD673A0007FDAC /* _WKVisitedLinkStoreInternal.h in Headers */,	8857	1A81B38518BD673A0007FDAC /* _WKVisitedLinkStoreInternal.h in Headers */,
8854	1AE286781C7E76510069AC4F /* _WKWebsiteDataSize.h in Headers */,	8858	1AE286781C7E76510069AC4F /* _WKWebsiteDataSize.h in Headers */,
		8859	E4D54D0421F1D72D007E3C36 /* ScrollingTreeFrameScrollingNodeRemoteIOS.h in Headers */,
8855	1AE286801C7F92C00069AC4F /* _WKWebsiteDataSizeInternal.h in Headers */,	8860	1AE286801C7F92C00069AC4F /* _WKWebsiteDataSizeInternal.h in Headers */,
8856	1AFB4C721ADF155D00B33339 /* _WKWebsiteDataStore.h in Headers */,	8861	1AFB4C721ADF155D00B33339 /* _WKWebsiteDataStore.h in Headers */,
8857	5120C8351E5B74B90025B250 /* _WKWebsiteDataStoreConfiguration.h in Headers */,	8862	5120C8351E5B74B90025B250 /* _WKWebsiteDataStoreConfiguration.h in Headers */,
Lines 9830-9836 Source/WebKit/WebKit.xcodeproj/project.pbxproj_sec6
9830	1DB01943211CF002009FB3E8 /* WKShareSheet.h in Headers */,	9835	1DB01943211CF002009FB3E8 /* WKShareSheet.h in Headers */,
9831	513E462D1AD837560016234A /* WKSharingServicePickerDelegate.h in Headers */,	9836	513E462D1AD837560016234A /* WKSharingServicePickerDelegate.h in Headers */,
9832	93F549B41E3174B7000E7239 /* WKSnapshotConfiguration.h in Headers */,	9837	93F549B41E3174B7000E7239 /* WKSnapshotConfiguration.h in Headers */,
9833	4118DC1F21E7BF5D00DE04C7 /* WKStorageQuotaDelegatePrivate.h in Headers */,
9834	BC407606124FF0270068F20A /* WKString.h in Headers */,	9838	BC407606124FF0270068F20A /* WKString.h in Headers */,
9835	BC40761A124FF0370068F20A /* WKStringCF.h in Headers */,	9839	BC40761A124FF0370068F20A /* WKStringCF.h in Headers */,
9836	BC9099801256A98200083756 /* WKStringPrivate.h in Headers */,	9840	BC9099801256A98200083756 /* WKStringPrivate.h in Headers */,