Attachment #354854 for bug #191640

View Details Raw Unified Return to Bug 191640

| Differences between



2018-11-14  Chris Dumez  <cdumez@apple.com>

        WebKit.DecidePolicyForNavigationActionForHyperlinkThatRedirects API fails when PSON is enabled
        https://bugs.webkit.org/show_bug.cgi?id=191640

        Reviewed by NOBODY (OOPS!).

        The issue was that when process-swapping on a redirect, the parameters provided by the new
        WebContent process for navigationActionData / originatingFrameInfoData / frameSecurityOrigin
        are not correct because it does not have sufficient information (it does not know a swap
        happened).

        To address the issue, we now store the navigationActionData / originatingFrameInfoData /
        frameSecurityOrigin on the Navigation object whenever decidePolicyForNavigationAction is
        called. If the decidePolicyForNavigationAction is for a redirect, use the ones we stored
        on the Navigation object instead of the ones provided by the WebContent process. In case
        of redirect, those do not change anyway.

        This fixes all WebKit.DecidePolicyForNavigationAction* tests with PSON enabled.

        * UIProcess/API/APINavigation.h:
        (API::Navigation::currentRequestIsRedirect const):
        (API::Navigation::wasUserInitiated const):
        (API::Navigation::shouldForceDownload const):
        (API::Navigation::treatAsSameOriginNavigation const):
        (API::Navigation::hasOpenedFrames const):
        (API::Navigation::openedViaWindowOpenWithOpener const):
        (API::Navigation::opener const):
        (API::Navigation::requesterOrigin const):
        (API::Navigation::lockHistory const):
        (API::Navigation::lockBackForwardList const):
        (API::Navigation::clientRedirectSourceForHistory const):
        (API::Navigation::setLastNavigationAction):
        (API::Navigation::lastNavigationAction const):
        (API::Navigation::setOriginatingFrameInfo):
        (API::Navigation::originatingFrameInfo const):
        (API::Navigation::setDestinationFrameSecurityOrigin):
        (API::Navigation::destinationFrameSecurityOrigin const):
        * UIProcess/WebPageProxy.cpp:
        (WebKit::WebPageProxy::decidePolicyForNavigationActionAsync):
        (WebKit::WebPageProxy::decidePolicyForNavigationAction):
        (WebKit::WebPageProxy::decidePolicyForNavigationActionSync):
        * UIProcess/WebPageProxy.h:

2018-11-14  Chris Dumez  <cdumez@apple.com>

        WebKit.ApplicationManifestBasic API test is failing when enabling PSON




#include "APIObject.h"
#include "DataReference.h"
#include "FrameInfoData.h"
#include "NavigationActionData.h"
#include "WebBackForwardListItem.h"
#include <WebCore/Process.h>
#include <WebCore/ResourceRequest.h>

    const WebCore::ResourceRequest& currentRequest() const { return m_currentRequest; }
    std::optional<WebCore::ProcessIdentifier> currentRequestProcessIdentifier() const { return m_currentRequestProcessIdentifier; }

    bool currentRequestIsRedirect() const { return m_lastNavigationAction.isRedirect; }
    bool currentRequestIsRedirect() const { return m_isRedirect; }

    void setTargetItem(WebKit::WebBackForwardListItem& item) { m_targetItem = &item; }
    WebKit::WebBackForwardListItem* targetItem() const { return m_targetItem.get(); }

    void appendRedirectionURL(const WebCore::URL&);
    Vector<WebCore::URL> takeRedirectChain() { return WTFMove(m_redirectChain); }

    bool wasUserInitiated() const { return !!m_lastNavigationAction.userGestureTokenIdentifier; }
    bool wasUserInitiated() const { return m_wasUserInitiated; }

    bool shouldForceDownload() const
    {
#if USE(SYSTEM_PREVIEW)
        return !m_lastNavigationAction.downloadAttribute.isNull() || currentRequest().isSystemPreview();
#else
        return !m_lastNavigationAction.downloadAttribute.isNull();
#endif
    }

    bool treatAsSameOriginNavigation() const { return m_lastNavigationAction.treatAsSameOriginNavigation; }
    bool hasOpenedFrames() const { return m_lastNavigationAction.hasOpenedFrames; }
    bool openedViaWindowOpenWithOpener() const { return m_lastNavigationAction.openedViaWindowOpenWithOpener; }
    const std::optional<std::pair<uint64_t, uint64_t>>& opener() const { return m_lastNavigationAction.opener; }
    const WebCore::SecurityOriginData& requesterOrigin() const { return m_lastNavigationAction.requesterOrigin; }

    WebCore::LockHistory lockHistory() const { return m_lastNavigationAction.lockHistory; }
    WebCore::LockBackForwardList lockBackForwardList() const { return m_lastNavigationAction.lockBackForwardList; }

    WTF::String clientRedirectSourceForHistory() const { return m_lastNavigationAction.clientRedirectSourceForHistory; }
    const WebCore::SecurityOriginData& requesterOrigin() const { return m_requesterOrigin; }

    void setLastNavigationAction(const WebKit::NavigationActionData& navigationAction) { m_lastNavigationAction = navigationAction; }
    const WebKit::NavigationActionData& lastNavigationAction() const { return m_lastNavigationAction; }

    void setOriginatingFrameInfo(const WebKit::FrameInfoData& frameInfo) { m_originatingFrameInfo = frameInfo; }
    const WebKit::FrameInfoData& originatingFrameInfo() const { return m_originatingFrameInfo; }

    void setDestinationFrameSecurityOrigin(const WebCore::SecurityOriginData& origin) { m_destinationFrameSecurityOrigin = origin; }
    const WebCore::SecurityOriginData& destinationFrameSecurityOrigin() const { return m_destinationFrameSecurityOrigin; }

#if !LOG_DISABLED
    const char* loggingString() const;

    WebCore::ResourceRequest m_currentRequest;
    std::optional<WebCore::ProcessIdentifier> m_currentRequestProcessIdentifier;
    Vector<WebCore::URL> m_redirectChain;
    bool m_wasUserInitiated { true };
    bool m_shouldForceDownload { false };
    bool m_isRedirect { false };

    RefPtr<WebKit::WebBackForwardListItem> m_targetItem;
    RefPtr<WebKit::WebBackForwardListItem> m_fromItem;
    std::optional<WebCore::FrameLoadType> m_backForwardFrameLoadType;
    bool m_treatAsSameOriginNavigation { false };
    bool m_hasOpenedFrames { false };
    bool m_openedViaWindowOpenWithOpener { false };
    std::optional<std::pair<uint64_t, uint64_t>> m_opener;
    WebCore::SecurityOriginData m_requesterOrigin;
    WebCore::LockHistory m_lockHistory;
    WebCore::LockBackForwardList m_lockBackForwardList;
    WTF::String m_clientRedirectSourceForHistory;
    std::unique_ptr<SubstituteData> m_substituteData;
    WebKit::NavigationActionData m_lastNavigationAction;
    WebKit::FrameInfoData m_originatingFrameInfo;
    WebCore::SecurityOriginData m_destinationFrameSecurityOrigin;
};

} // namespace API



}
#endif

void WebPageProxy::decidePolicyForNavigationActionAsync(uint64_t frameID, WebCore::SecurityOriginData&& frameSecurityOrigin, uint64_t navigationID, NavigationActionData&& navigationActionData, FrameInfoData&& frameInfoData, uint64_t originatingPageID, const WebCore::ResourceRequest& originalRequest, WebCore::ResourceRequest&& request, IPC::FormDataReference&& requestBody, WebCore::ResourceResponse&& redirectResponse, const UserData& userData, WebCore::ShouldSkipSafeBrowsingCheck shouldSkipSafeBrowsingCheck, uint64_t listenerID)
{
    auto* frame = m_process->webFrame(frameID);
    MESSAGE_CHECK(frame);

    decidePolicyForNavigationAction(*frame, WTFMove(frameSecurityOrigin), navigationID, WTFMove(navigationActionData), WTFMove(frameInfoData), originatingPageID, originalRequest, WTFMove(request), WTFMove(requestBody), WTFMove(redirectResponse), userData, shouldSkipSafeBrowsingCheck, PolicyDecisionSender::create([this, protectedThis = makeRef(*this), frameID, listenerID] (auto... args) {
        m_process->send(Messages::WebPage::DidReceivePolicyDecision(frameID, listenerID, args...), m_pageID);
    }));
}

void WebPageProxy::decidePolicyForNavigationAction(WebFrameProxy& frame, WebCore::SecurityOriginData&& frameSecurityOrigin, uint64_t navigationID, NavigationActionData&& navigationActionData, FrameInfoData&& originatingFrameInfoData, uint64_t originatingPageID, const WebCore::ResourceRequest& originalRequest, WebCore::ResourceRequest&& request, IPC::FormDataReference&& requestBody, WebCore::ResourceResponse&& redirectResponse, const UserData& userData, WebCore::ShouldSkipSafeBrowsingCheck shouldSkipSafeBrowsingCheck, Ref<PolicyDecisionSender>&& sender)
{
    LOG(Loading, "WebPageProxy::decidePolicyForNavigationAction - Original URL %s, current target URL %s", originalRequest.url().string().utf8().data(), request.url().string().utf8().data());


    if (navigationID)
        navigation = m_navigationState->navigation(navigationID);

    // When process-swapping on a redirect, the navigationActionData / originatingFrameInfoData / frameSecurityOrigin provided by the fresh new WebProcess are inaccurate since
    // the new process does not have sufficient information. To address the issue, we restore the information we stored on the NavigationAction during the original request
    // policy decision.
    if (navigationActionData.isRedirect && navigation) {
        navigationActionData = navigation->lastNavigationAction();
        navigationActionData.isRedirect = true;
        originatingFrameInfoData = navigation->originatingFrameInfo();
        frameSecurityOrigin = navigation->destinationFrameSecurityOrigin();
    }

    if (auto targetBackForwardItemIdentifier = navigationActionData.targetBackForwardItemIdentifier) {
        if (auto* item = m_backForwardList->itemForID(*navigationActionData.targetBackForwardItemIdentifier)) {
            if (!navigation)

        navigation = m_navigationState->createLoadRequestNavigation(ResourceRequest(request), m_backForwardList->currentItem());

    uint64_t newNavigationID = navigation->navigationID();
    navigation->setWasUserInitiated(!!navigationActionData.userGestureTokenIdentifier);
#if USE(SYSTEM_PREVIEW)
    navigation->setShouldForceDownload(!navigationActionData.downloadAttribute.isNull() || request.isSystemPreview());
#else
    navigation->setShouldForceDownload(!navigationActionData.downloadAttribute.isNull());
#endif
    navigation->setCurrentRequest(ResourceRequest(request), m_process->coreProcessIdentifier());
    navigation->setLastNavigationAction(navigationActionData);
    navigation->setOriginatingFrameInfo(originatingFrameInfoData);
    navigation->setDestinationFrameSecurityOrigin(frameSecurityOrigin);
    if (navigationActionData.openedViaWindowOpenWithOpener)
        navigation->setOpenedViaWindowOpenWithOpener();
    navigation->setOpener(navigationActionData.opener);
    navigation->setRequesterOrigin(navigationActionData.requesterOrigin);
    navigation->setLockHistory(navigationActionData.lockHistory);
    navigation->setLockBackForwardList(navigationActionData.lockBackForwardList);
    navigation->setClientRedirectSourceForHistory(navigationActionData.clientRedirectSourceForHistory);

#if ENABLE(CONTENT_FILTERING)
    if (frame.didHandleContentFilterUnblockNavigation(request))

    m_shouldSuppressAppLinksInNextNavigationPolicyDecision = false;
}

void WebPageProxy::decidePolicyForNavigationActionSync(uint64_t frameID, bool isMainFrame, WebCore::SecurityOriginData&& frameSecurityOrigin, uint64_t navigationID, NavigationActionData&& navigationActionData, FrameInfoData&& frameInfoData, uint64_t originatingPageID, const WebCore::ResourceRequest& originalRequest, WebCore::ResourceRequest&& request, IPC::FormDataReference&& requestBody, WebCore::ResourceResponse&& redirectResponse, const UserData& userData, WebCore::ShouldSkipSafeBrowsingCheck shouldSkipSafeBrowsingCheck, Messages::WebPageProxy::DecidePolicyForNavigationActionSync::DelayedReply&& reply)
{
    auto sender = PolicyDecisionSender::create(WTFMove(reply));


        RELEASE_ASSERT(frame);
    }

    decidePolicyForNavigationAction(*frame, WTFMove(frameSecurityOrigin), navigationID, WTFMove(navigationActionData), WTFMove(frameInfoData), originatingPageID, originalRequest, WTFMove(request), WTFMove(requestBody), WTFMove(redirectResponse), userData, shouldSkipSafeBrowsingCheck, sender.copyRef());

    // If the client did not respond synchronously, proceed with the load.
    sender->send(PolicyAction::Use, navigationID, DownloadID(), std::nullopt);




    void didDestroyNavigation(uint64_t navigationID);

    void decidePolicyForNavigationAction(WebFrameProxy&, WebCore::SecurityOriginData&& frameSecurityOrigin, uint64_t navigationID, NavigationActionData&&, FrameInfoData&&, uint64_t originatingPageID, const WebCore::ResourceRequest& originalRequest, WebCore::ResourceRequest&&, IPC::FormDataReference&& requestBody, WebCore::ResourceResponse&& redirectResponse, const UserData&, WebCore::ShouldSkipSafeBrowsingCheck, Ref<PolicyDecisionSender>&&);
    void decidePolicyForNavigationActionAsync(uint64_t frameID, WebCore::SecurityOriginData&& frameSecurityOrigin, uint64_t navigationID, NavigationActionData&&, FrameInfoData&&, uint64_t originatingPageID, const WebCore::ResourceRequest& originalRequest, WebCore::ResourceRequest&&, IPC::FormDataReference&& requestBody, WebCore::ResourceResponse&& redirectResponse, const UserData&, WebCore::ShouldSkipSafeBrowsingCheck, uint64_t listenerID);
    void decidePolicyForNavigationActionSync(uint64_t frameID, bool isMainFrame, WebCore::SecurityOriginData&& frameSecurityOrigin, uint64_t navigationID, NavigationActionData&&, FrameInfoData&&, uint64_t originatingPageID, const WebCore::ResourceRequest& originalRequest, WebCore::ResourceRequest&&, IPC::FormDataReference&& requestBody, WebCore::ResourceResponse&& redirectResponse, const UserData&, WebCore::ShouldSkipSafeBrowsingCheck, Messages::WebPageProxy::DecidePolicyForNavigationActionSync::DelayedReply&&);
    void decidePolicyForNewWindowAction(uint64_t frameID, const WebCore::SecurityOriginData& frameSecurityOrigin, NavigationActionData&&, WebCore::ResourceRequest&&, const String& frameName, uint64_t listenerID, const UserData&);
    void decidePolicyForResponse(uint64_t frameID, const WebCore::SecurityOriginData& frameSecurityOrigin, uint64_t navigationID, const WebCore::ResourceResponse&, const WebCore::ResourceRequest&, bool canShowMIMEType, uint64_t listenerID, const UserData&);
    void unableToImplementPolicy(uint64_t frameID, const WebCore::ResourceError&, const UserData&);



2018-11-14  Chris Dumez  <cdumez@apple.com>

        WebKit.DecidePolicyForNavigationActionForHyperlinkThatRedirects API fails when PSON is enabled
        https://bugs.webkit.org/show_bug.cgi?id=191640

        Reviewed by NOBODY (OOPS!).

        Add API test coverage.

        * TestWebKitAPI/Tests/WebKitCocoa/DecidePolicyForNavigationAction.mm:
        (runDecidePolicyForNavigationActionForHyperlinkThatRedirects):
        (TEST):

2018-11-14  Chris Dumez  <cdumez@apple.com>

        WebKit.ApplicationManifestBasic API test is failing when enabling PSON

Lines 30-35 a/Tools/TestWebKitAPI/Tests/WebKitCocoa/DecidePolicyForNavigationAction.mm_sec1
- a/Tools/TestWebKitAPI/Tests/WebKitCocoa/DecidePolicyForNavigationAction.mm -2 / +22 lines
30	#import "PlatformUtilities.h"	30	#import "PlatformUtilities.h"
31	#import "TestProtocol.h"	31	#import "TestProtocol.h"
32	#import <WebKit/WKNavigationActionPrivate.h>	32	#import <WebKit/WKNavigationActionPrivate.h>
		33	#import <WebKit/WKProcessPoolPrivate.h>
		34	#import <WebKit/_WKProcessPoolConfiguration.h>
33	#import <wtf/RetainPtr.h>	35	#import <wtf/RetainPtr.h>
34	#import <wtf/mac/AppKitCompatibilityDeclarations.h>	36	#import <wtf/mac/AppKitCompatibilityDeclarations.h>
35		37
Lines 431-439 TEST(WebKit, DecidePolicyForNavigationActionForTargetedFormSubmission) a/Tools/TestWebKitAPI/Tests/WebKitCocoa/DecidePolicyForNavigationAction.mm_sec2
431	action = nullptr;	433	action = nullptr;
432	}	434	}
433		435
434	TEST(WebKit, DecidePolicyForNavigationActionForHyperlinkThatRedirects)	436	enum class ShouldEnableProcessSwap { No, Yes };
		437	static void runDecidePolicyForNavigationActionForHyperlinkThatRedirects(ShouldEnableProcessSwap shouldEnableProcessSwap)
435	{	438	{
436	auto webView = adoptNS([[WKWebView alloc] initWithFrame:NSMakeRect(0, 0, 800, 600)]);	439	auto processPoolConfiguration = adoptNS([[_WKProcessPoolConfiguration alloc] init]);
		440	processPoolConfiguration.get().processSwapsOnNavigation = shouldEnableProcessSwap == ShouldEnableProcessSwap::Yes ? YES : NO;
		441	auto processPool = adoptNS([[WKProcessPool alloc] _initWithConfiguration:processPoolConfiguration.get()]);
		442
		443	auto webViewConfiguration = adoptNS([[WKWebViewConfiguration alloc] init]);
		444	[webViewConfiguration setProcessPool:processPool.get()];
		445
		446	auto webView = adoptNS([[WKWebView alloc] initWithFrame:NSMakeRect(0, 0, 800, 600) configuration:webViewConfiguration.get()]);
437		447
438	auto window = adoptNS([[NSWindow alloc] initWithContentRect:[webView frame] styleMask:NSWindowStyleMaskBorderless backing:NSBackingStoreBuffered defer:YES]);	448	auto window = adoptNS([[NSWindow alloc] initWithContentRect:[webView frame] styleMask:NSWindowStyleMaskBorderless backing:NSBackingStoreBuffered defer:YES]);
439	[[window contentView] addSubview:webView.get()];	449	[[window contentView] addSubview:webView.get()];
Lines 481-486 TEST(WebKit, DecidePolicyForNavigationActionForHyperlinkThatRedirects) a/Tools/TestWebKitAPI/Tests/WebKitCocoa/DecidePolicyForNavigationAction.mm_sec3
481	action = nullptr;	491	action = nullptr;
482	}	492	}
483		493
		494	TEST(WebKit, DecidePolicyForNavigationActionForHyperlinkThatRedirectsWithoutPSON)
		495	{
		496	runDecidePolicyForNavigationActionForHyperlinkThatRedirects(ShouldEnableProcessSwap::No);
		497	}
		498
		499	TEST(WebKit, DecidePolicyForNavigationActionForHyperlinkThatRedirectsWithPSON)
		500	{
		501	runDecidePolicyForNavigationActionForHyperlinkThatRedirects(ShouldEnableProcessSwap::Yes);
		502	}
		503
484	TEST(WebKit, DecidePolicyForNavigationActionForPOSTFormSubmissionThatRedirectsToGET)	504	TEST(WebKit, DecidePolicyForNavigationActionForPOSTFormSubmissionThatRedirectsToGET)
485	{	505	{
486	auto webView = adoptNS([[WKWebView alloc] initWithFrame:NSMakeRect(0, 0, 800, 600)]);	506	auto webView = adoptNS([[WKWebView alloc] initWithFrame:NSMakeRect(0, 0, 800, 600)]);

Return to Bug 191640

Lines 27-32 a/Source/WebKit/UIProcess/API/APINavigation.h_sec1
- a/Source/WebKit/UIProcess/API/APINavigation.h -35 / +29 lines
27		27
28	#include "APIObject.h"	28	#include "APIObject.h"
29	#include "DataReference.h"	29	#include "DataReference.h"
		30	#include "FrameInfoData.h"
		31	#include "NavigationActionData.h"
30	#include "WebBackForwardListItem.h"	32	#include "WebBackForwardListItem.h"
31	#include <WebCore/Process.h>	33	#include <WebCore/Process.h>
32	#include <WebCore/ResourceRequest.h>	34	#include <WebCore/ResourceRequest.h>
Lines 93-100 public: a/Source/WebKit/UIProcess/API/APINavigation.h_sec2
93	const WebCore::ResourceRequest& currentRequest() const { return m_currentRequest; }	95	const WebCore::ResourceRequest& currentRequest() const { return m_currentRequest; }
94	std::optional<WebCore::ProcessIdentifier> currentRequestProcessIdentifier() const { return m_currentRequestProcessIdentifier; }	96	std::optional<WebCore::ProcessIdentifier> currentRequestProcessIdentifier() const { return m_currentRequestProcessIdentifier; }
95		97
96	void setCurrentRequestIsRedirect(bool isRedirect) { m_isRedirect = isRedirect; }	98	bool currentRequestIsRedirect() const { return m_lastNavigationAction.isRedirect; }
97	bool currentRequestIsRedirect() const { return m_isRedirect; }
98		99
99	void setTargetItem(WebKit::WebBackForwardListItem& item) { m_targetItem = &item; }	100	void setTargetItem(WebKit::WebBackForwardListItem& item) { m_targetItem = &item; }
100	WebKit::WebBackForwardListItem* targetItem() const { return m_targetItem.get(); }	101	WebKit::WebBackForwardListItem* targetItem() const { return m_targetItem.get(); }
Lines 104-138 public: a/Source/WebKit/UIProcess/API/APINavigation.h_sec3
104	void appendRedirectionURL(const WebCore::URL&);	105	void appendRedirectionURL(const WebCore::URL&);
105	Vector<WebCore::URL> takeRedirectChain() { return WTFMove(m_redirectChain); }	106	Vector<WebCore::URL> takeRedirectChain() { return WTFMove(m_redirectChain); }
106		107
107	void setWasUserInitiated(bool value) { m_wasUserInitiated = value; }	108	bool wasUserInitiated() const { return !!m_lastNavigationAction.userGestureTokenIdentifier; }
108	bool wasUserInitiated() const { return m_wasUserInitiated; }
109		109
110	void setShouldForceDownload(bool value) { m_shouldForceDownload = value; }	110	bool shouldForceDownload() const
111	bool shouldForceDownload() const { return m_shouldForceDownload; }	111	{
112		112	#if USE(SYSTEM_PREVIEW)
113	void setTreatAsSameOriginNavigation(bool value) { m_treatAsSameOriginNavigation = value; }	113	return !m_lastNavigationAction.downloadAttribute.isNull() \|\| currentRequest().isSystemPreview();
114	bool treatAsSameOriginNavigation() const { return m_treatAsSameOriginNavigation; }	114	#else
115		115	return !m_lastNavigationAction.downloadAttribute.isNull();
116	void setHasOpenedFrames(bool value) { m_hasOpenedFrames = value; }	116	#endif
117	bool hasOpenedFrames() const { return m_hasOpenedFrames; }	117	}
118		118
119	bool openedViaWindowOpenWithOpener() const { return m_openedViaWindowOpenWithOpener; }	119	bool treatAsSameOriginNavigation() const { return m_lastNavigationAction.treatAsSameOriginNavigation; }
120	void setOpenedViaWindowOpenWithOpener() { m_openedViaWindowOpenWithOpener = true; }	120	bool hasOpenedFrames() const { return m_lastNavigationAction.hasOpenedFrames; }
		121	bool openedViaWindowOpenWithOpener() const { return m_lastNavigationAction.openedViaWindowOpenWithOpener; }
		122	const std::optional<std::pair<uint64_t, uint64_t>>& opener() const { return m_lastNavigationAction.opener; }
		123	const WebCore::SecurityOriginData& requesterOrigin() const { return m_lastNavigationAction.requesterOrigin; }
121		124
122	void setOpener(const std::optional<std::pair<uint64_t, uint64_t>>& opener) { m_opener = opener; }	125	WebCore::LockHistory lockHistory() const { return m_lastNavigationAction.lockHistory; }
123	const std::optional<std::pair<uint64_t, uint64_t>>& opener() const { return m_opener; }	126	WebCore::LockBackForwardList lockBackForwardList() const { return m_lastNavigationAction.lockBackForwardList; }
124		127
125	void setRequesterOrigin(const WebCore::SecurityOriginData& origin) { m_requesterOrigin = origin; }	128	WTF::String clientRedirectSourceForHistory() const { return m_lastNavigationAction.clientRedirectSourceForHistory; }
126	const WebCore::SecurityOriginData& requesterOrigin() const { return m_requesterOrigin; }
127		129
128	void setLockHistory(WebCore::LockHistory lockHistory) { m_lockHistory = lockHistory; }	130	void setLastNavigationAction(const WebKit::NavigationActionData& navigationAction) { m_lastNavigationAction = navigationAction; }
129	WebCore::LockHistory lockHistory() const { return m_lockHistory; }	131	const WebKit::NavigationActionData& lastNavigationAction() const { return m_lastNavigationAction; }
130		132
131	void setLockBackForwardList(WebCore::LockBackForwardList lockBackForwardList) { m_lockBackForwardList = lockBackForwardList; }	133	void setOriginatingFrameInfo(const WebKit::FrameInfoData& frameInfo) { m_originatingFrameInfo = frameInfo; }
132	WebCore::LockBackForwardList lockBackForwardList() const { return m_lockBackForwardList; }	134	const WebKit::FrameInfoData& originatingFrameInfo() const { return m_originatingFrameInfo; }
133		135
134	void setClientRedirectSourceForHistory(const WTF::String& clientRedirectSourceForHistory) { m_clientRedirectSourceForHistory = clientRedirectSourceForHistory; }	136	void setDestinationFrameSecurityOrigin(const WebCore::SecurityOriginData& origin) { m_destinationFrameSecurityOrigin = origin; }
135	WTF::String clientRedirectSourceForHistory() const { return m_clientRedirectSourceForHistory; }	137	const WebCore::SecurityOriginData& destinationFrameSecurityOrigin() const { return m_destinationFrameSecurityOrigin; }
136		138
137	#if !LOG_DISABLED	139	#if !LOG_DISABLED
138	const char* loggingString() const;	140	const char* loggingString() const;
Lines 151-172 private: a/Source/WebKit/UIProcess/API/APINavigation.h_sec4
151	WebCore::ResourceRequest m_currentRequest;	153	WebCore::ResourceRequest m_currentRequest;
152	std::optional<WebCore::ProcessIdentifier> m_currentRequestProcessIdentifier;	154	std::optional<WebCore::ProcessIdentifier> m_currentRequestProcessIdentifier;
153	Vector<WebCore::URL> m_redirectChain;	155	Vector<WebCore::URL> m_redirectChain;
154	bool m_wasUserInitiated { true };
155	bool m_shouldForceDownload { false };
156	bool m_isRedirect { false };
157		156
158	RefPtr<WebKit::WebBackForwardListItem> m_targetItem;	157	RefPtr<WebKit::WebBackForwardListItem> m_targetItem;
159	RefPtr<WebKit::WebBackForwardListItem> m_fromItem;	158	RefPtr<WebKit::WebBackForwardListItem> m_fromItem;
160	std::optional<WebCore::FrameLoadType> m_backForwardFrameLoadType;	159	std::optional<WebCore::FrameLoadType> m_backForwardFrameLoadType;
161	bool m_treatAsSameOriginNavigation { false };
162	bool m_hasOpenedFrames { false };
163	bool m_openedViaWindowOpenWithOpener { false };
164	std::optional<std::pair<uint64_t, uint64_t>> m_opener;
165	WebCore::SecurityOriginData m_requesterOrigin;
166	WebCore::LockHistory m_lockHistory;
167	WebCore::LockBackForwardList m_lockBackForwardList;
168	WTF::String m_clientRedirectSourceForHistory;
169	std::unique_ptr<SubstituteData> m_substituteData;	160	std::unique_ptr<SubstituteData> m_substituteData;
		161	WebKit::NavigationActionData m_lastNavigationAction;
		162	WebKit::FrameInfoData m_originatingFrameInfo;
		163	WebCore::SecurityOriginData m_destinationFrameSecurityOrigin;
170	};	164	};
171		165
172	} // namespace API	166	} // namespace API

Lines 4091-4107 void WebPageProxy::beginSafeBrowsingCheck(const URL&, WebFramePolicyListenerProx a/Source/WebKit/UIProcess/WebPageProxy.cpp_sec1
- a/Source/WebKit/UIProcess/WebPageProxy.cpp -21 / +18 lines
4091	}	4091	}
4092	#endif	4092	#endif
4093		4093
4094	void WebPageProxy::decidePolicyForNavigationActionAsync(uint64_t frameID, const WebCore::SecurityOriginData& frameSecurityOrigin, uint64_t navigationID, NavigationActionData&& navigationActionData, const FrameInfoData& frameInfoData, uint64_t originatingPageID, const WebCore::ResourceRequest& originalRequest, WebCore::ResourceRequest&& request, IPC::FormDataReference&& requestBody, WebCore::ResourceResponse&& redirectResponse, const UserData& userData, WebCore::ShouldSkipSafeBrowsingCheck shouldSkipSafeBrowsingCheck, uint64_t listenerID)	4094	void WebPageProxy::decidePolicyForNavigationActionAsync(uint64_t frameID, WebCore::SecurityOriginData&& frameSecurityOrigin, uint64_t navigationID, NavigationActionData&& navigationActionData, FrameInfoData&& frameInfoData, uint64_t originatingPageID, const WebCore::ResourceRequest& originalRequest, WebCore::ResourceRequest&& request, IPC::FormDataReference&& requestBody, WebCore::ResourceResponse&& redirectResponse, const UserData& userData, WebCore::ShouldSkipSafeBrowsingCheck shouldSkipSafeBrowsingCheck, uint64_t listenerID)
4095	{	4095	{
4096	auto* frame = m_process->webFrame(frameID);	4096	auto* frame = m_process->webFrame(frameID);
4097	MESSAGE_CHECK(frame);	4097	MESSAGE_CHECK(frame);
4098		4098
4099	decidePolicyForNavigationAction(frame, frameSecurityOrigin, navigationID, WTFMove(navigationActionData), frameInfoData, originatingPageID, originalRequest, WTFMove(request), WTFMove(requestBody), WTFMove(redirectResponse), userData, shouldSkipSafeBrowsingCheck, PolicyDecisionSender::create([this, protectedThis = makeRef(this), frameID, listenerID] (auto... args) {	4099	decidePolicyForNavigationAction(frame, WTFMove(frameSecurityOrigin), navigationID, WTFMove(navigationActionData), WTFMove(frameInfoData), originatingPageID, originalRequest, WTFMove(request), WTFMove(requestBody), WTFMove(redirectResponse), userData, shouldSkipSafeBrowsingCheck, PolicyDecisionSender::create([this, protectedThis = makeRef(this), frameID, listenerID] (auto... args) {
4100	m_process->send(Messages::WebPage::DidReceivePolicyDecision(frameID, listenerID, args...), m_pageID);	4100	m_process->send(Messages::WebPage::DidReceivePolicyDecision(frameID, listenerID, args...), m_pageID);
4101	}));	4101	}));
4102	}	4102	}
4103		4103
4104	void WebPageProxy::decidePolicyForNavigationAction(WebFrameProxy& frame, const WebCore::SecurityOriginData& frameSecurityOrigin, uint64_t navigationID, NavigationActionData&& navigationActionData, const FrameInfoData& originatingFrameInfoData, uint64_t originatingPageID, const WebCore::ResourceRequest& originalRequest, WebCore::ResourceRequest&& request, IPC::FormDataReference&& requestBody, WebCore::ResourceResponse&& redirectResponse, const UserData& userData, WebCore::ShouldSkipSafeBrowsingCheck shouldSkipSafeBrowsingCheck, Ref<PolicyDecisionSender>&& sender)	4104	void WebPageProxy::decidePolicyForNavigationAction(WebFrameProxy& frame, WebCore::SecurityOriginData&& frameSecurityOrigin, uint64_t navigationID, NavigationActionData&& navigationActionData, FrameInfoData&& originatingFrameInfoData, uint64_t originatingPageID, const WebCore::ResourceRequest& originalRequest, WebCore::ResourceRequest&& request, IPC::FormDataReference&& requestBody, WebCore::ResourceResponse&& redirectResponse, const UserData& userData, WebCore::ShouldSkipSafeBrowsingCheck shouldSkipSafeBrowsingCheck, Ref<PolicyDecisionSender>&& sender)
4105	{	4105	{
4106	LOG(Loading, "WebPageProxy::decidePolicyForNavigationAction - Original URL %s, current target URL %s", originalRequest.url().string().utf8().data(), request.url().string().utf8().data());	4106	LOG(Loading, "WebPageProxy::decidePolicyForNavigationAction - Original URL %s, current target URL %s", originalRequest.url().string().utf8().data(), request.url().string().utf8().data());
4107		4107
Lines 4123-4128 void WebPageProxy::decidePolicyForNavigationAction(WebFrameProxy& frame, const W a/Source/WebKit/UIProcess/WebPageProxy.cpp_sec2
4123	if (navigationID)	4123	if (navigationID)
4124	navigation = m_navigationState->navigation(navigationID);	4124	navigation = m_navigationState->navigation(navigationID);
4125		4125
		4126	// When process-swapping on a redirect, the navigationActionData / originatingFrameInfoData / frameSecurityOrigin provided by the fresh new WebProcess are inaccurate since
		4127	// the new process does not have sufficient information. To address the issue, we restore the information we stored on the NavigationAction during the original request
		4128	// policy decision.
		4129	if (navigationActionData.isRedirect && navigation) {
		4130	navigationActionData = navigation->lastNavigationAction();
		4131	navigationActionData.isRedirect = true;
		4132	originatingFrameInfoData = navigation->originatingFrameInfo();
		4133	frameSecurityOrigin = navigation->destinationFrameSecurityOrigin();
		4134	}
		4135
4126	if (auto targetBackForwardItemIdentifier = navigationActionData.targetBackForwardItemIdentifier) {	4136	if (auto targetBackForwardItemIdentifier = navigationActionData.targetBackForwardItemIdentifier) {
4127	if (auto* item = m_backForwardList->itemForID(*navigationActionData.targetBackForwardItemIdentifier)) {	4137	if (auto* item = m_backForwardList->itemForID(*navigationActionData.targetBackForwardItemIdentifier)) {
4128	if (!navigation)	4138	if (!navigation)
Lines 4136-4158 void WebPageProxy::decidePolicyForNavigationAction(WebFrameProxy& frame, const W a/Source/WebKit/UIProcess/WebPageProxy.cpp_sec3
4136	navigation = m_navigationState->createLoadRequestNavigation(ResourceRequest(request), m_backForwardList->currentItem());	4146	navigation = m_navigationState->createLoadRequestNavigation(ResourceRequest(request), m_backForwardList->currentItem());
4137		4147
4138	uint64_t newNavigationID = navigation->navigationID();	4148	uint64_t newNavigationID = navigation->navigationID();
4139	navigation->setWasUserInitiated(!!navigationActionData.userGestureTokenIdentifier);
4140	#if USE(SYSTEM_PREVIEW)
4141	navigation->setShouldForceDownload(!navigationActionData.downloadAttribute.isNull() \|\| request.isSystemPreview());
4142	#else
4143	navigation->setShouldForceDownload(!navigationActionData.downloadAttribute.isNull());
4144	#endif
4145	navigation->setCurrentRequest(ResourceRequest(request), m_process->coreProcessIdentifier());	4149	navigation->setCurrentRequest(ResourceRequest(request), m_process->coreProcessIdentifier());
4146	navigation->setCurrentRequestIsRedirect(navigationActionData.isRedirect);	4150	navigation->setLastNavigationAction(navigationActionData);
4147	navigation->setTreatAsSameOriginNavigation(navigationActionData.treatAsSameOriginNavigation);	4151	navigation->setOriginatingFrameInfo(originatingFrameInfoData);
4148	navigation->setHasOpenedFrames(navigationActionData.hasOpenedFrames);	4152	navigation->setDestinationFrameSecurityOrigin(frameSecurityOrigin);
4149	if (navigationActionData.openedViaWindowOpenWithOpener)
4150	navigation->setOpenedViaWindowOpenWithOpener();
4151	navigation->setOpener(navigationActionData.opener);
4152	navigation->setRequesterOrigin(navigationActionData.requesterOrigin);
4153	navigation->setLockHistory(navigationActionData.lockHistory);
4154	navigation->setLockBackForwardList(navigationActionData.lockBackForwardList);
4155	navigation->setClientRedirectSourceForHistory(navigationActionData.clientRedirectSourceForHistory);
4156		4153
4157	#if ENABLE(CONTENT_FILTERING)	4154	#if ENABLE(CONTENT_FILTERING)
4158	if (frame.didHandleContentFilterUnblockNavigation(request))	4155	if (frame.didHandleContentFilterUnblockNavigation(request))
Lines 4228-4234 void WebPageProxy::decidePolicyForNavigationAction(WebFrameProxy& frame, const W a/Source/WebKit/UIProcess/WebPageProxy.cpp_sec4
4228	m_shouldSuppressAppLinksInNextNavigationPolicyDecision = false;	4225	m_shouldSuppressAppLinksInNextNavigationPolicyDecision = false;
4229	}	4226	}
4230		4227
4231	void WebPageProxy::decidePolicyForNavigationActionSync(uint64_t frameID, bool isMainFrame, const WebCore::SecurityOriginData& frameSecurityOrigin, uint64_t navigationID, NavigationActionData&& navigationActionData, const FrameInfoData& frameInfoData, uint64_t originatingPageID, const WebCore::ResourceRequest& originalRequest, WebCore::ResourceRequest&& request, IPC::FormDataReference&& requestBody, WebCore::ResourceResponse&& redirectResponse, const UserData& userData, WebCore::ShouldSkipSafeBrowsingCheck shouldSkipSafeBrowsingCheck, Messages::WebPageProxy::DecidePolicyForNavigationActionSync::DelayedReply&& reply)	4228	void WebPageProxy::decidePolicyForNavigationActionSync(uint64_t frameID, bool isMainFrame, WebCore::SecurityOriginData&& frameSecurityOrigin, uint64_t navigationID, NavigationActionData&& navigationActionData, FrameInfoData&& frameInfoData, uint64_t originatingPageID, const WebCore::ResourceRequest& originalRequest, WebCore::ResourceRequest&& request, IPC::FormDataReference&& requestBody, WebCore::ResourceResponse&& redirectResponse, const UserData& userData, WebCore::ShouldSkipSafeBrowsingCheck shouldSkipSafeBrowsingCheck, Messages::WebPageProxy::DecidePolicyForNavigationActionSync::DelayedReply&& reply)
4232	{	4229	{
4233	auto sender = PolicyDecisionSender::create(WTFMove(reply));	4230	auto sender = PolicyDecisionSender::create(WTFMove(reply));
4234		4231
Lines 4244-4250 void WebPageProxy::decidePolicyForNavigationActionSync(uint64_t frameID, bool is a/Source/WebKit/UIProcess/WebPageProxy.cpp_sec5
4244	RELEASE_ASSERT(frame);	4241	RELEASE_ASSERT(frame);
4245	}	4242	}
4246		4243
4247	decidePolicyForNavigationAction(*frame, frameSecurityOrigin, navigationID, WTFMove(navigationActionData), frameInfoData, originatingPageID, originalRequest, WTFMove(request), WTFMove(requestBody), WTFMove(redirectResponse), userData, shouldSkipSafeBrowsingCheck, sender.copyRef());	4244	decidePolicyForNavigationAction(*frame, WTFMove(frameSecurityOrigin), navigationID, WTFMove(navigationActionData), WTFMove(frameInfoData), originatingPageID, originalRequest, WTFMove(request), WTFMove(requestBody), WTFMove(redirectResponse), userData, shouldSkipSafeBrowsingCheck, sender.copyRef());
4248		4245
4249	// If the client did not respond synchronously, proceed with the load.	4246	// If the client did not respond synchronously, proceed with the load.
4250	sender->send(PolicyAction::Use, navigationID, DownloadID(), std::nullopt);	4247	sender->send(PolicyAction::Use, navigationID, DownloadID(), std::nullopt);

Lines 1453-1461 private: a/Source/WebKit/UIProcess/WebPageProxy.h_sec1
- a/Source/WebKit/UIProcess/WebPageProxy.h -3 / +3 lines
1453		1453
1454	void didDestroyNavigation(uint64_t navigationID);	1454	void didDestroyNavigation(uint64_t navigationID);
1455		1455
1456	void decidePolicyForNavigationAction(WebFrameProxy&, const WebCore::SecurityOriginData& frameSecurityOrigin, uint64_t navigationID, NavigationActionData&&, const FrameInfoData&, uint64_t originatingPageID, const WebCore::ResourceRequest& originalRequest, WebCore::ResourceRequest&&, IPC::FormDataReference&& requestBody, WebCore::ResourceResponse&& redirectResponse, const UserData&, WebCore::ShouldSkipSafeBrowsingCheck, Ref<PolicyDecisionSender>&&);	1456	void decidePolicyForNavigationAction(WebFrameProxy&, WebCore::SecurityOriginData&& frameSecurityOrigin, uint64_t navigationID, NavigationActionData&&, FrameInfoData&&, uint64_t originatingPageID, const WebCore::ResourceRequest& originalRequest, WebCore::ResourceRequest&&, IPC::FormDataReference&& requestBody, WebCore::ResourceResponse&& redirectResponse, const UserData&, WebCore::ShouldSkipSafeBrowsingCheck, Ref<PolicyDecisionSender>&&);
1457	void decidePolicyForNavigationActionAsync(uint64_t frameID, const WebCore::SecurityOriginData& frameSecurityOrigin, uint64_t navigationID, NavigationActionData&&, const FrameInfoData&, uint64_t originatingPageID, const WebCore::ResourceRequest& originalRequest, WebCore::ResourceRequest&&, IPC::FormDataReference&& requestBody, WebCore::ResourceResponse&& redirectResponse, const UserData&, WebCore::ShouldSkipSafeBrowsingCheck, uint64_t listenerID);	1457	void decidePolicyForNavigationActionAsync(uint64_t frameID, WebCore::SecurityOriginData&& frameSecurityOrigin, uint64_t navigationID, NavigationActionData&&, FrameInfoData&&, uint64_t originatingPageID, const WebCore::ResourceRequest& originalRequest, WebCore::ResourceRequest&&, IPC::FormDataReference&& requestBody, WebCore::ResourceResponse&& redirectResponse, const UserData&, WebCore::ShouldSkipSafeBrowsingCheck, uint64_t listenerID);
1458	void decidePolicyForNavigationActionSync(uint64_t frameID, bool isMainFrame, const WebCore::SecurityOriginData& frameSecurityOrigin, uint64_t navigationID, NavigationActionData&&, const FrameInfoData&, uint64_t originatingPageID, const WebCore::ResourceRequest& originalRequest, WebCore::ResourceRequest&&, IPC::FormDataReference&& requestBody, WebCore::ResourceResponse&& redirectResponse, const UserData&, WebCore::ShouldSkipSafeBrowsingCheck, Messages::WebPageProxy::DecidePolicyForNavigationActionSync::DelayedReply&&);	1458	void decidePolicyForNavigationActionSync(uint64_t frameID, bool isMainFrame, WebCore::SecurityOriginData&& frameSecurityOrigin, uint64_t navigationID, NavigationActionData&&, FrameInfoData&&, uint64_t originatingPageID, const WebCore::ResourceRequest& originalRequest, WebCore::ResourceRequest&&, IPC::FormDataReference&& requestBody, WebCore::ResourceResponse&& redirectResponse, const UserData&, WebCore::ShouldSkipSafeBrowsingCheck, Messages::WebPageProxy::DecidePolicyForNavigationActionSync::DelayedReply&&);
1459	void decidePolicyForNewWindowAction(uint64_t frameID, const WebCore::SecurityOriginData& frameSecurityOrigin, NavigationActionData&&, WebCore::ResourceRequest&&, const String& frameName, uint64_t listenerID, const UserData&);	1459	void decidePolicyForNewWindowAction(uint64_t frameID, const WebCore::SecurityOriginData& frameSecurityOrigin, NavigationActionData&&, WebCore::ResourceRequest&&, const String& frameName, uint64_t listenerID, const UserData&);
1460	void decidePolicyForResponse(uint64_t frameID, const WebCore::SecurityOriginData& frameSecurityOrigin, uint64_t navigationID, const WebCore::ResourceResponse&, const WebCore::ResourceRequest&, bool canShowMIMEType, uint64_t listenerID, const UserData&);	1460	void decidePolicyForResponse(uint64_t frameID, const WebCore::SecurityOriginData& frameSecurityOrigin, uint64_t navigationID, const WebCore::ResourceResponse&, const WebCore::ResourceRequest&, bool canShowMIMEType, uint64_t listenerID, const UserData&);
1461	void unableToImplementPolicy(uint64_t frameID, const WebCore::ResourceError&, const UserData&);	1461	void unableToImplementPolicy(uint64_t frameID, const WebCore::ResourceError&, const UserData&);

Lines 1-3 a/Source/WebKit/ChangeLog_sec1
- a/Source/WebKit/ChangeLog +44 lines
		1	2018-11-14 Chris Dumez <cdumez@apple.com>
		2
		3	WebKit.DecidePolicyForNavigationActionForHyperlinkThatRedirects API fails when PSON is enabled
		4	https://bugs.webkit.org/show_bug.cgi?id=191640
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	The issue was that when process-swapping on a redirect, the parameters provided by the new
		9	WebContent process for navigationActionData / originatingFrameInfoData / frameSecurityOrigin
		10	are not correct because it does not have sufficient information (it does not know a swap
		11	happened).
		12
		13	To address the issue, we now store the navigationActionData / originatingFrameInfoData /
		14	frameSecurityOrigin on the Navigation object whenever decidePolicyForNavigationAction is
		15	called. If the decidePolicyForNavigationAction is for a redirect, use the ones we stored
		16	on the Navigation object instead of the ones provided by the WebContent process. In case
		17	of redirect, those do not change anyway.
		18
		19	This fixes all WebKit.DecidePolicyForNavigationAction* tests with PSON enabled.
		20
		21	* UIProcess/API/APINavigation.h:
		22	(API::Navigation::currentRequestIsRedirect const):
		23	(API::Navigation::wasUserInitiated const):
		24	(API::Navigation::shouldForceDownload const):
		25	(API::Navigation::treatAsSameOriginNavigation const):
		26	(API::Navigation::hasOpenedFrames const):
		27	(API::Navigation::openedViaWindowOpenWithOpener const):
		28	(API::Navigation::opener const):
		29	(API::Navigation::requesterOrigin const):
		30	(API::Navigation::lockHistory const):
		31	(API::Navigation::lockBackForwardList const):
		32	(API::Navigation::clientRedirectSourceForHistory const):
		33	(API::Navigation::setLastNavigationAction):
		34	(API::Navigation::lastNavigationAction const):
		35	(API::Navigation::setOriginatingFrameInfo):
		36	(API::Navigation::originatingFrameInfo const):
		37	(API::Navigation::setDestinationFrameSecurityOrigin):
		38	(API::Navigation::destinationFrameSecurityOrigin const):
		39	* UIProcess/WebPageProxy.cpp:
		40	(WebKit::WebPageProxy::decidePolicyForNavigationActionAsync):
		41	(WebKit::WebPageProxy::decidePolicyForNavigationAction):
		42	(WebKit::WebPageProxy::decidePolicyForNavigationActionSync):
		43	* UIProcess/WebPageProxy.h:
		44
1	2018-11-14 Chris Dumez <cdumez@apple.com>	45	2018-11-14 Chris Dumez <cdumez@apple.com>
2		46
3	WebKit.ApplicationManifestBasic API test is failing when enabling PSON	47	WebKit.ApplicationManifestBasic API test is failing when enabling PSON

Lines 1-3 a/Tools/ChangeLog_sec1
- a/Tools/ChangeLog +13 lines
		1	2018-11-14 Chris Dumez <cdumez@apple.com>
		2
		3	WebKit.DecidePolicyForNavigationActionForHyperlinkThatRedirects API fails when PSON is enabled
		4	https://bugs.webkit.org/show_bug.cgi?id=191640
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Add API test coverage.
		9
		10	* TestWebKitAPI/Tests/WebKitCocoa/DecidePolicyForNavigationAction.mm:
		11	(runDecidePolicyForNavigationActionForHyperlinkThatRedirects):
		12	(TEST):
		13
1	2018-11-14 Chris Dumez <cdumez@apple.com>	14	2018-11-14 Chris Dumez <cdumez@apple.com>
2		15
3	WebKit.ApplicationManifestBasic API test is failing when enabling PSON	16	WebKit.ApplicationManifestBasic API test is failing when enabling PSON