Changeset 222541 in webkit


Ignore:
Timestamp:
Sep 26, 2017 6:39:00 PM (7 years ago)
Author:
achristensen@apple.com
Message:

Pass a completion handler instead of a WebFramePolicyListenerProxy during policy decisions
​https://bugs.webkit.org/show_bug.cgi?id=177509

Reviewed by Tim Horton.

This makes WebFramePolicyListenerProxy just a wrapper around a WTF::Function which is only needed for the C and glib APIs.
This is a step towards making WebPageProxy::DecidePolicyForResponseSync and WebPageProxy::DecidePolicyForNavigationAction asynchronous.

This patch has no change in behavior.

  • CMakeLists.txt:
  • UIProcess/API/APINavigationClient.h:

(API::NavigationClient::decidePolicyForNavigationAction):
(API::NavigationClient::decidePolicyForNavigationResponse):

  • UIProcess/API/APIPolicyClient.h:

(API::PolicyClient::decidePolicyForNavigationAction):
(API::PolicyClient::decidePolicyForNewWindowAction):
(API::PolicyClient::decidePolicyForResponse):

  • UIProcess/API/C/WKFramePolicyListener.cpp:

(WKFramePolicyListenerUseWithPolicies):

  • UIProcess/API/C/WKPage.cpp:

(WKPageSetPagePolicyClient):
(WKPageSetPageNavigationClient):

  • UIProcess/API/Cocoa/WKBrowsingContextController.mm:
  • UIProcess/API/glib/WebKitPolicyClient.cpp:
  • UIProcess/Automation/WebAutomationSession.cpp:
  • UIProcess/Cocoa/NavigationState.h:
  • UIProcess/Cocoa/NavigationState.mm:

(WebKit::NavigationState::NavigationClient::decidePolicyForNavigationAction):
(WebKit::NavigationState::NavigationClient::decidePolicyForNavigationResponse):

  • UIProcess/Cocoa/WebViewImpl.mm:
  • UIProcess/RemoteWebInspectorProxy.cpp:
  • UIProcess/WebFormSubmissionListenerProxy.h:
  • UIProcess/WebFrameListenerProxy.cpp: Removed.
  • UIProcess/WebFrameListenerProxy.h: Removed.
  • UIProcess/WebFramePolicyListenerProxy.cpp:

(WebKit::WebFramePolicyListenerProxy::WebFramePolicyListenerProxy):
(WebKit::WebFramePolicyListenerProxy::~WebFramePolicyListenerProxy):
(WebKit::WebFramePolicyListenerProxy::create):
(WebKit::WebFramePolicyListenerProxy::use):
(WebKit::WebFramePolicyListenerProxy::download):
(WebKit::WebFramePolicyListenerProxy::ignore):

  • UIProcess/WebFramePolicyListenerProxy.h:

(WebKit::WebFramePolicyListenerProxy::create): Deleted.
(): Deleted.
(WebKit::WebFramePolicyListenerProxy::operator new): Deleted.

  • UIProcess/WebFrameProxy.cpp:

(WebKit::WebFrameProxy::webProcessWillShutDown):
(WebKit::WebFrameProxy::receivedPolicyDecision): Deleted.
(WebKit::WebFrameProxy::setUpPolicyListenerProxy): Deleted.

  • UIProcess/WebFrameProxy.h:
  • UIProcess/WebInspectorProxy.cpp:
  • UIProcess/WebPageProxy.cpp:

(WebKit::WebPageProxy::decidePolicyForNavigationAction):
(WebKit::WebPageProxy::decidePolicyForNewWindowAction):
(WebKit::WebPageProxy::decidePolicyForResponseSync):
(WebKit::WebPageProxy::receivedPolicyDecision): Deleted.
(WebKit::WebPageProxy::decidePolicyForResponse): Deleted.

  • UIProcess/WebPageProxy.h:
  • UIProcess/mac/ViewGestureControllerMac.mm:
  • WebKit.xcodeproj/project.pbxproj:
Location:
trunk/Source/WebKit
Files:
2 deleted
25 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit/CMakeLists.txt

    r222194 r222541  
    314314    UIProcess/WebFormClient.cpp
    315315    UIProcess/WebFormSubmissionListenerProxy.cpp
    316     UIProcess/WebFrameListenerProxy.cpp
    317316    UIProcess/WebFramePolicyListenerProxy.cpp
    318317    UIProcess/WebFrameProxy.cpp

  • trunk/Source/WebKit/ChangeLog

    r222536 r222541  
     12017-09-26  Alex Christensen  <achristensen@webkit.org>
     2
     3        Pass a completion handler instead of a WebFramePolicyListenerProxy during policy decisions
     4        https://bugs.webkit.org/show_bug.cgi?id=177509
     5
     6        Reviewed by Tim Horton.
     7
     8        This makes WebFramePolicyListenerProxy just a wrapper around a WTF::Function which is only needed for the C and glib APIs.
     9        This is a step towards making WebPageProxy::DecidePolicyForResponseSync and WebPageProxy::DecidePolicyForNavigationAction asynchronous.
     10
     11        This patch has no change in behavior.
     12
     13        * CMakeLists.txt:
     14        * UIProcess/API/APINavigationClient.h:
     15        (API::NavigationClient::decidePolicyForNavigationAction):
     16        (API::NavigationClient::decidePolicyForNavigationResponse):
     17        * UIProcess/API/APIPolicyClient.h:
     18        (API::PolicyClient::decidePolicyForNavigationAction):
     19        (API::PolicyClient::decidePolicyForNewWindowAction):
     20        (API::PolicyClient::decidePolicyForResponse):
     21        * UIProcess/API/C/WKFramePolicyListener.cpp:
     22        (WKFramePolicyListenerUseWithPolicies):
     23        * UIProcess/API/C/WKPage.cpp:
     24        (WKPageSetPagePolicyClient):
     25        (WKPageSetPageNavigationClient):
     26        * UIProcess/API/Cocoa/WKBrowsingContextController.mm:
     27        * UIProcess/API/glib/WebKitPolicyClient.cpp:
     28        * UIProcess/Automation/WebAutomationSession.cpp:
     29        * UIProcess/Cocoa/NavigationState.h:
     30        * UIProcess/Cocoa/NavigationState.mm:
     31        (WebKit::NavigationState::NavigationClient::decidePolicyForNavigationAction):
     32        (WebKit::NavigationState::NavigationClient::decidePolicyForNavigationResponse):
     33        * UIProcess/Cocoa/WebViewImpl.mm:
     34        * UIProcess/RemoteWebInspectorProxy.cpp:
     35        * UIProcess/WebFormSubmissionListenerProxy.h:
     36        * UIProcess/WebFrameListenerProxy.cpp: Removed.
     37        * UIProcess/WebFrameListenerProxy.h: Removed.
     38        * UIProcess/WebFramePolicyListenerProxy.cpp:
     39        (WebKit::WebFramePolicyListenerProxy::WebFramePolicyListenerProxy):
     40        (WebKit::WebFramePolicyListenerProxy::~WebFramePolicyListenerProxy):
     41        (WebKit::WebFramePolicyListenerProxy::create):
     42        (WebKit::WebFramePolicyListenerProxy::use):
     43        (WebKit::WebFramePolicyListenerProxy::download):
     44        (WebKit::WebFramePolicyListenerProxy::ignore):
     45        * UIProcess/WebFramePolicyListenerProxy.h:
     46        (WebKit::WebFramePolicyListenerProxy::create): Deleted.
     47        (): Deleted.
     48        (WebKit::WebFramePolicyListenerProxy::operator new): Deleted.
     49        * UIProcess/WebFrameProxy.cpp:
     50        (WebKit::WebFrameProxy::webProcessWillShutDown):
     51        (WebKit::WebFrameProxy::receivedPolicyDecision): Deleted.
     52        (WebKit::WebFrameProxy::setUpPolicyListenerProxy): Deleted.
     53        * UIProcess/WebFrameProxy.h:
     54        * UIProcess/WebInspectorProxy.cpp:
     55        * UIProcess/WebPageProxy.cpp:
     56        (WebKit::WebPageProxy::decidePolicyForNavigationAction):
     57        (WebKit::WebPageProxy::decidePolicyForNewWindowAction):
     58        (WebKit::WebPageProxy::decidePolicyForResponseSync):
     59        (WebKit::WebPageProxy::receivedPolicyDecision): Deleted.
     60        (WebKit::WebPageProxy::decidePolicyForResponse): Deleted.
     61        * UIProcess/WebPageProxy.h:
     62        * UIProcess/mac/ViewGestureControllerMac.mm:
     63        * WebKit.xcodeproj/project.pbxproj:
     64
    1652017-09-26  Brian Burg  <bburg@apple.com>
    266

  • trunk/Source/WebKit/UIProcess/API/APINavigationClient.h

    r222462 r222541  
    2727
    2828#include "APIData.h"
     29#include "DownloadID.h"
    2930#include "PluginModuleInfo.h"
    3031#include "ProcessTerminationReason.h"
    3132#include "SameDocumentNavigationType.h"
    3233#include "WebEvent.h"
    33 #include "WebFramePolicyListenerProxy.h"
    3434#include "WebsitePolicies.h"
    3535#include <WebCore/FrameLoaderTypes.h>
    … …  
    4141class ResourceRequest;
    4242class ResourceResponse;
     43class URL;
    4344struct SecurityOriginData;
    4445}
    … …  
    4647namespace WebKit {
    4748class AuthenticationChallengeProxy;
     49class DownloadID;
    4850class QuickLookDocumentData;
    4951class WebBackForwardListItem;
    50 class WebFramePolicyListenerProxy;
    5152class WebFrameProxy;
    5253class WebPageProxy;
    … …  
    9798#endif
    9899
    99     virtual void decidePolicyForNavigationAction(WebKit::WebPageProxy&, Ref<NavigationAction>&&, Ref<WebKit::WebFramePolicyListenerProxy>&& listener, Object*)
     100    virtual void decidePolicyForNavigationAction(WebKit::WebPageProxy&, Ref<NavigationAction>&&, Function<void(WebCore::PolicyAction, std::optional<WebKit::WebsitePolicies>&&)>&& completionHandler, Object*)
    100101    {
    101         listener->use({ });
     102        completionHandler(WebCore::PolicyAction::Use, std::nullopt);
    102103    }
    103104
    104     virtual void decidePolicyForNavigationResponse(WebKit::WebPageProxy&, NavigationResponse&, Ref<WebKit::WebFramePolicyListenerProxy>&& listener, Object*)
     105    virtual void decidePolicyForNavigationResponse(WebKit::WebPageProxy&, NavigationResponse&, Function<void(WebCore::PolicyAction, std::optional<WebKit::WebsitePolicies>&&)>&& completionHandler, Object*)
    105106    {
    106         listener->use({ });
     107        completionHandler(WebCore::PolicyAction::Use, std::nullopt);
    107108    }
    108109   

  • trunk/Source/WebKit/UIProcess/API/APIPolicyClient.h

    r219871 r222541  
    2727
    2828#include "WebEvent.h"
    29 #include "WebFramePolicyListenerProxy.h"
    3029#include "WebsitePolicies.h"
    3130#include <WebCore/FrameLoaderTypes.h>
    … …  
    3938
    4039namespace WebKit {
     40class DownloadID;
    4141struct NavigationActionData;
    4242class WebPageProxy;
    4343class WebFrameProxy;
    44 class WebFramePolicyListenerProxy;
    4544}
    4645
    … …  
    5251    virtual ~PolicyClient() { }
    5352
    54     virtual void decidePolicyForNavigationAction(WebKit::WebPageProxy&, WebKit::WebFrameProxy*, const WebKit::NavigationActionData&, WebKit::WebFrameProxy*, const WebCore::ResourceRequest&, const WebCore::ResourceRequest&, Ref<WebKit::WebFramePolicyListenerProxy>&& listener, API::Object*)
     53    virtual void decidePolicyForNavigationAction(WebKit::WebPageProxy&, WebKit::WebFrameProxy*, const WebKit::NavigationActionData&, WebKit::WebFrameProxy*, const WebCore::ResourceRequest&, const WebCore::ResourceRequest&, Function<void(WebCore::PolicyAction, std::optional<WebKit::WebsitePolicies>&&)>&& completionHandler, API::Object*)
    5554    {
    56         listener->use({ });
     55        completionHandler(WebCore::PolicyAction::Use, std::nullopt);
    5756    }
    58     virtual void decidePolicyForNewWindowAction(WebKit::WebPageProxy&, WebKit::WebFrameProxy&, const WebKit::NavigationActionData&, const WebCore::ResourceRequest&, const WTF::String&, Ref<WebKit::WebFramePolicyListenerProxy>&& listener, API::Object*)
     57    virtual void decidePolicyForNewWindowAction(WebKit::WebPageProxy&, WebKit::WebFrameProxy&, const WebKit::NavigationActionData&, const WebCore::ResourceRequest&, const WTF::String&, Function<void(WebCore::PolicyAction, std::optional<WebKit::WebsitePolicies>&&)>&& completionHandler, API::Object*)
    5958    {
    60         listener->use({ });
     59        completionHandler(WebCore::PolicyAction::Use, std::nullopt);
    6160    }
    62     virtual void decidePolicyForResponse(WebKit::WebPageProxy&, WebKit::WebFrameProxy&, const WebCore::ResourceResponse&, const WebCore::ResourceRequest&, bool, Ref<WebKit::WebFramePolicyListenerProxy>&& listener, API::Object*)
     61    virtual void decidePolicyForResponse(WebKit::WebPageProxy&, WebKit::WebFrameProxy&, const WebCore::ResourceResponse&, const WebCore::ResourceRequest&, bool, Function<void(WebCore::PolicyAction, std::optional<WebKit::WebsitePolicies>&&)>&& completionHandler, API::Object*)
    6362    {
    64         listener->use({ });
     63        completionHandler(WebCore::PolicyAction::Use, std::nullopt);
    6564    }
    6665    virtual void unableToImplementPolicy(WebKit::WebPageProxy&, WebKit::WebFrameProxy&, const WebCore::ResourceError&, API::Object*) { }

  • trunk/Source/WebKit/UIProcess/API/C/WKFramePolicyListener.cpp

    r209558 r222541  
    4545}
    4646
    47 void WKFramePolicyListenerUseWithPolicies(WKFramePolicyListenerRef policyListenerRef, WKWebsitePoliciesRef websitePolicies)
     47void WKFramePolicyListenerUseWithPolicies(WKFramePolicyListenerRef policyListenerRef, WKWebsitePoliciesRef websitePoliciesRef)
    4848{
    49     toImpl(policyListenerRef)->use(toImpl(websitePolicies)->websitePolicies());
     49    auto websitePolicies = toImpl(websitePoliciesRef)->websitePolicies();
     50    toImpl(policyListenerRef)->use(WTFMove(websitePolicies));
    5051}
    5152

  • trunk/Source/WebKit/UIProcess/API/C/WKPage.cpp

    r222462 r222541  
    3939#include "APIHitTestResult.h"
    4040#include "APILoaderClient.h"
     41#include "APINavigation.h"
    4142#include "APINavigationAction.h"
    4243#include "APINavigationClient.h"
    … …  
    6364#include "WebBackForwardList.h"
    6465#include "WebFormClient.h"
     66#include "WebFramePolicyListenerProxy.h"
    6567#include "WebImage.h"
    6668#include "WebInspectorProxy.h"
    … …  
    13491351
    13501352    private:
    1351         void decidePolicyForNavigationAction(WebPageProxy& page, WebFrameProxy* frame, const NavigationActionData& navigationActionData, WebFrameProxy* originatingFrame, const WebCore::ResourceRequest& originalResourceRequest, const WebCore::ResourceRequest& resourceRequest, Ref<WebFramePolicyListenerProxy>&& listener, API::Object* userData) override
     1353        void decidePolicyForNavigationAction(WebPageProxy& page, WebFrameProxy* frame, const NavigationActionData& navigationActionData, WebFrameProxy* originatingFrame, const WebCore::ResourceRequest& originalResourceRequest, const WebCore::ResourceRequest& resourceRequest, Function<void(WebCore::PolicyAction, std::optional<WebKit::WebsitePolicies>&&)>&& completionHandler, API::Object* userData) override
    13521354        {
    13531355            if (!m_client.decidePolicyForNavigationAction_deprecatedForUseWithV0 && !m_client.decidePolicyForNavigationAction_deprecatedForUseWithV1 && !m_client.decidePolicyForNavigationAction) {
    1354                 listener->use({ });
     1356                completionHandler(WebCore::PolicyAction::Use, std::nullopt);
    13551357                return;
    13561358            }
    13571359
     1360            auto listener = WebFramePolicyListenerProxy::create(WTFMove(completionHandler));
    13581361            Ref<API::URLRequest> originalRequest = API::URLRequest::create(originalResourceRequest);
    13591362            Ref<API::URLRequest> request = API::URLRequest::create(resourceRequest);
    … …  
    13671370        }
    13681371
    1369         void decidePolicyForNewWindowAction(WebPageProxy& page, WebFrameProxy& frame, const NavigationActionData& navigationActionData, const ResourceRequest& resourceRequest, const String& frameName, Ref<WebFramePolicyListenerProxy>&& listener, API::Object* userData) override
     1372        void decidePolicyForNewWindowAction(WebPageProxy& page, WebFrameProxy& frame, const NavigationActionData& navigationActionData, const ResourceRequest& resourceRequest, const String& frameName, Function<void(WebCore::PolicyAction, std::optional<WebKit::WebsitePolicies>&&)>&& completionHandler, API::Object* userData) override
    13701373        {
    13711374            if (!m_client.decidePolicyForNewWindowAction) {
    1372                 listener->use({ });
     1375                completionHandler(WebCore::PolicyAction::Use, std::nullopt);
    13731376                return;
    13741377            }
    13751378
     1379            auto listener = WebFramePolicyListenerProxy::create(WTFMove(completionHandler));
    13761380            Ref<API::URLRequest> request = API::URLRequest::create(resourceRequest);
    13771381
    … …  
    13791383        }
    13801384
    1381         void decidePolicyForResponse(WebPageProxy& page, WebFrameProxy& frame, const ResourceResponse& resourceResponse, const ResourceRequest& resourceRequest, bool canShowMIMEType, Ref<WebFramePolicyListenerProxy>&& listener, API::Object* userData) override
     1385        void decidePolicyForResponse(WebPageProxy& page, WebFrameProxy& frame, const ResourceResponse& resourceResponse, const ResourceRequest& resourceRequest, bool canShowMIMEType, Function<void(WebCore::PolicyAction, std::optional<WebKit::WebsitePolicies>&&)>&& completionHandler, API::Object* userData) override
    13821386        {
    13831387            if (!m_client.decidePolicyForResponse_deprecatedForUseWithV0 && !m_client.decidePolicyForResponse) {
    1384                 listener->use({ });
     1388                completionHandler(WebCore::PolicyAction::Use, std::nullopt);
    13851389                return;
    13861390            }
    13871391
     1392            auto listener = WebFramePolicyListenerProxy::create(WTFMove(completionHandler));
    13881393            Ref<API::URLResponse> response = API::URLResponse::create(resourceResponse);
    13891394            Ref<API::URLRequest> request = API::URLRequest::create(resourceRequest);
    … …  
    21412146
    21422147    private:
    2143         void decidePolicyForNavigationAction(WebPageProxy& page, Ref<API::NavigationAction>&& navigationAction, Ref<WebKit::WebFramePolicyListenerProxy>&& listener, API::Object* userData) final
     2148        void decidePolicyForNavigationAction(WebPageProxy& page, Ref<API::NavigationAction>&& navigationAction, Function<void(WebCore::PolicyAction, std::optional<WebKit::WebsitePolicies>&&)>&& completionHandler, API::Object* userData) final
    21442149        {
    21452150            if (!m_client.decidePolicyForNavigationAction) {
    2146                 listener->use({ });
     2151                completionHandler(WebCore::PolicyAction::Use, std::nullopt);
    21472152                return;
    21482153            }
     2154            auto listener = WebFramePolicyListenerProxy::create(WTFMove(completionHandler));
    21492155            m_client.decidePolicyForNavigationAction(toAPI(&page), toAPI(navigationAction.ptr()), toAPI(listener.ptr()), toAPI(userData), m_client.base.clientInfo);
    21502156        }
    21512157
    2152         void decidePolicyForNavigationResponse(WebPageProxy& page, API::NavigationResponse& navigationResponse, Ref<WebKit::WebFramePolicyListenerProxy>&& listener, API::Object* userData) override
     2158        void decidePolicyForNavigationResponse(WebPageProxy& page, API::NavigationResponse& navigationResponse, Function<void(WebCore::PolicyAction, std::optional<WebKit::WebsitePolicies>&&)>&& completionHandler, API::Object* userData) override
    21532159        {
    21542160            if (!m_client.decidePolicyForNavigationResponse) {
    2155                 listener->use({ });
     2161                completionHandler(WebCore::PolicyAction::Use, std::nullopt);
    21562162                return;
    21572163            }
     2164            auto listener = WebFramePolicyListenerProxy::create(WTFMove(completionHandler));
    21582165            m_client.decidePolicyForNavigationResponse(toAPI(&page), toAPI(&navigationResponse), toAPI(listener.ptr()), toAPI(userData), m_client.base.clientInfo);
    21592166        }

  • trunk/Source/WebKit/UIProcess/API/Cocoa/WKBrowsingContextController.mm

    r222059 r222541  
    3030
    3131#import "APIData.h"
     32#import "APINavigation.h"
    3233#import "ObjCObjectGraph.h"
    3334#import "PageLoadStateObserver.h"

  • trunk/Source/WebKit/UIProcess/API/glib/WebKitPolicyClient.cpp

    r218487 r222541  
    3939
    4040private:
    41     void decidePolicyForNavigationAction(WebPageProxy&, WebFrameProxy*, const NavigationActionData& navigationActionData, WebFrameProxy* /*originatingFrame*/, const WebCore::ResourceRequest& /*originalRequest*/, const WebCore::ResourceRequest& request, Ref<WebFramePolicyListenerProxy>&& listener, API::Object* /*userData*/) override
     41    void decidePolicyForNavigationAction(WebPageProxy&, WebFrameProxy*, const NavigationActionData& navigationActionData, WebFrameProxy* /*originatingFrame*/, const WebCore::ResourceRequest& /*originalRequest*/, const WebCore::ResourceRequest& request, Function<void(WebCore::PolicyAction, std::optional<WebKit::WebsitePolicies>&&)>&& completionHandler, API::Object* /*userData*/) override
    4242    {
     43        auto listener = WebFramePolicyListenerProxy::create(WTFMove(completionHandler));
    4344        GRefPtr<WebKitPolicyDecision> decision = adoptGRef(webkitNavigationPolicyDecisionCreate(navigationActionData, request, listener.ptr()));
    4445        webkitWebViewMakePolicyDecision(m_webView, WEBKIT_POLICY_DECISION_TYPE_NAVIGATION_ACTION, decision.get());
    4546    }
    4647
    47     void decidePolicyForNewWindowAction(WebPageProxy&, WebFrameProxy&, const NavigationActionData& navigationActionData, const WebCore::ResourceRequest& request, const String& frameName, Ref<WebFramePolicyListenerProxy>&& listener, API::Object* /*userData*/) override
     48    void decidePolicyForNewWindowAction(WebPageProxy&, WebFrameProxy&, const NavigationActionData& navigationActionData, const WebCore::ResourceRequest& request, const String& frameName, Function<void(WebCore::PolicyAction, std::optional<WebKit::WebsitePolicies>&&)>&& completionHandler, API::Object* /*userData*/) override
    4849    {
     50        auto listener = WebFramePolicyListenerProxy::create(WTFMove(completionHandler));
    4951        GRefPtr<WebKitPolicyDecision> decision = adoptGRef(webkitNewWindowPolicyDecisionCreate(navigationActionData, request, frameName, listener.ptr()));
    5052        webkitWebViewMakePolicyDecision(m_webView, WEBKIT_POLICY_DECISION_TYPE_NEW_WINDOW_ACTION, decision.get());
    5153    }
    5254
    53     void decidePolicyForResponse(WebPageProxy&, WebFrameProxy&, const WebCore::ResourceResponse& response, const WebCore::ResourceRequest& request, bool canShowMIMEType, Ref<WebFramePolicyListenerProxy>&& listener, API::Object* /*userData*/) override
     55    void decidePolicyForResponse(WebPageProxy&, WebFrameProxy&, const WebCore::ResourceResponse& response, const WebCore::ResourceRequest& request, bool canShowMIMEType, Function<void(WebCore::PolicyAction, std::optional<WebKit::WebsitePolicies>&&)>&& completionHandler, API::Object* /*userData*/) override
    5456    {
     57        auto listener = WebFramePolicyListenerProxy::create(WTFMove(completionHandler));
    5558        GRefPtr<WebKitPolicyDecision> decision = adoptGRef(webkitResponsePolicyDecisionCreate(request, response, canShowMIMEType, listener.ptr()));
    5659        webkitWebViewMakePolicyDecision(m_webView, WEBKIT_POLICY_DECISION_TYPE_RESPONSE, decision.get());

  • trunk/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp

    r222059 r222541  
    2424
    2525#include "APIData.h"
     26#include "APINavigation.h"
    2627#include "APISerializedScriptValue.h"
    2728#include "ImageOptions.h"

  • trunk/Source/WebKit/UIProcess/Automation/WebAutomationSession.cpp

    r222503 r222541  
    2929#include "APIArray.h"
    3030#include "APIAutomationSessionClient.h"
     31#include "APINavigation.h"
    3132#include "APIOpenPanelParameters.h"
    3233#include "AutomationProtocolObjects.h"

  • trunk/Source/WebKit/UIProcess/Cocoa/NavigationState.h

    r222462 r222541  
    122122#endif
    123123
    124         void decidePolicyForNavigationAction(WebPageProxy&, Ref<API::NavigationAction>&&, Ref<WebFramePolicyListenerProxy>&&, API::Object* userData) override;
    125         void decidePolicyForNavigationResponse(WebPageProxy&, API::NavigationResponse&, Ref<WebFramePolicyListenerProxy>&&, API::Object* userData) override;
     124        void decidePolicyForNavigationAction(WebPageProxy&, Ref<API::NavigationAction>&&, Function<void(WebCore::PolicyAction, std::optional<WebsitePolicies>&&)>&&, API::Object* userData) override;
     125        void decidePolicyForNavigationResponse(WebPageProxy&, API::NavigationResponse&, Function<void(WebCore::PolicyAction, std::optional<WebsitePolicies>&&)>&&, API::Object* userData) override;
    126126
    127127        NavigationState& m_navigationState;

  • trunk/Source/WebKit/UIProcess/Cocoa/NavigationState.mm

    r222462 r222541  
    361361}
    362362
    363 void NavigationState::NavigationClient::decidePolicyForNavigationAction(WebPageProxy& webPageProxy, Ref<API::NavigationAction>&& navigationAction, Ref<WebFramePolicyListenerProxy>&& listener, API::Object* userData)
     363void NavigationState::NavigationClient::decidePolicyForNavigationAction(WebPageProxy& webPageProxy, Ref<API::NavigationAction>&& navigationAction, Function<void(WebCore::PolicyAction, std::optional<WebsitePolicies>&&)>&& completionHandler, API::Object* userData)
    364364{
    365365    String mainFrameURLString = webPageProxy.mainFrame()->url();
    … …  
    368368        && !m_navigationState.m_navigationDelegateMethods.webViewDecidePolicyForNavigationActionDecisionHandlerWebsitePolicies) {
    369369        Ref<API::NavigationAction> localNavigationAction = navigationAction.copyRef();
    370         RefPtr<WebFramePolicyListenerProxy> localListener = WTFMove(listener);
    371 
    372         tryAppLink(WTFMove(localNavigationAction), mainFrameURLString, [webPage = RefPtr<WebPageProxy>(&webPageProxy), localListener, localNavigationAction = navigationAction.copyRef()] (bool followedLinkToApp) {
     370
     371        tryAppLink(WTFMove(localNavigationAction), mainFrameURLString, [webPage = RefPtr<WebPageProxy>(&webPageProxy), completionHandler = WTFMove(completionHandler), localNavigationAction = navigationAction.copyRef()] (bool followedLinkToApp) {
    373372            if (followedLinkToApp) {
    374                 localListener->ignore();
     373                completionHandler(PolicyAction::Ignore, std::nullopt);
    375374                return;
    376375            }
    377376
    378377            if (!localNavigationAction->targetFrame()) {
    379                 localListener->use({ });
     378                completionHandler(PolicyAction::Use, std::nullopt);
    380379                return;
    381380            }
    … …  
    384383            if ([NSURLConnection canHandleRequest:nsURLRequest.get()] || webPage->urlSchemeHandlerForScheme([nsURLRequest URL].scheme)) {
    385384                if (localNavigationAction->shouldPerformDownload())
    386                     localListener->download();
     385                    completionHandler(PolicyAction::Download, std::nullopt);
    387386                else
    388                     localListener->use({ });
     387                    completionHandler(PolicyAction::Use, std::nullopt);
    389388                return;
    390389            }
    … …  
    396395                [[NSWorkspace sharedWorkspace] openURL:[nsURLRequest URL]];
    397396#endif
    398             localListener->ignore();
     397            completionHandler(PolicyAction::Ignore, std::nullopt);
    399398        });
    400399
    … …  
    408407    bool delegateHasWebsitePolicies = m_navigationState.m_navigationDelegateMethods.webViewDecidePolicyForNavigationActionDecisionHandlerWebsitePolicies;
    409408   
    410     RefPtr<CompletionHandlerCallChecker> checker = CompletionHandlerCallChecker::create(navigationDelegate.get(), delegateHasWebsitePolicies ? @selector(_webView:decidePolicyForNavigationAction:decisionHandler:) : @selector(webView:decidePolicyForNavigationAction:decisionHandler:));
     409    auto checker = CompletionHandlerCallChecker::create(navigationDelegate.get(), delegateHasWebsitePolicies ? @selector(_webView:decidePolicyForNavigationAction:decisionHandler:) : @selector(webView:decidePolicyForNavigationAction:decisionHandler:));
    411410   
    412     auto decisionHandlerWithPolicies = [localListener = RefPtr<WebFramePolicyListenerProxy>(WTFMove(listener)), localNavigationAction = navigationAction.copyRef(), checker = WTFMove(checker), mainFrameURLString](WKNavigationActionPolicy actionPolicy, _WKWebsitePolicies *websitePolicies) mutable {
     411    auto decisionHandlerWithPolicies = [completionHandler = WTFMove(completionHandler), localNavigationAction = navigationAction.copyRef(), checker = WTFMove(checker), mainFrameURLString](WKNavigationActionPolicy actionPolicy, _WKWebsitePolicies *websitePolicies) mutable {
    413412        if (checker->completionHandlerHasBeenCalled())
    414413            return;
    415414        checker->didCallCompletionHandler();
    416415
    417         WebsitePolicies policies;
     416        std::optional<WebsitePolicies> policies;
    418417        if (websitePolicies)
    419418            policies = websitePolicies->_websitePolicies->websitePolicies();
    … …  
    421420        switch (actionPolicy) {
    422421        case WKNavigationActionPolicyAllow:
    423             tryAppLink(WTFMove(localNavigationAction), mainFrameURLString, [localListener = WTFMove(localListener), policies = WTFMove(policies)](bool followedLinkToApp) mutable {
     422            tryAppLink(WTFMove(localNavigationAction), mainFrameURLString, [completionHandler = WTFMove(completionHandler), policies = WTFMove(policies)](bool followedLinkToApp) mutable {
    424423                if (followedLinkToApp) {
    425                     localListener->ignore();
     424                    completionHandler(PolicyAction::Ignore, std::nullopt);
    426425                    return;
    427426                }
    428427
    429                 localListener->use(policies);
     428                completionHandler(PolicyAction::Use, WTFMove(policies));
    430429            });
    431430       
    … …  
    433432
    434433        case WKNavigationActionPolicyCancel:
    435             localListener->ignore();
     434            completionHandler(PolicyAction::Ignore, std::nullopt);
    436435            break;
    437436
    … …  
    440439#pragma clang diagnostic ignored "-Wswitch"
    441440        case _WKNavigationActionPolicyDownload:
    442             localListener->download();
     441            completionHandler(PolicyAction::Download, std::nullopt);
    443442            break;
    444443        case _WKNavigationActionPolicyAllowWithoutTryingAppLink:
    445444#pragma clang diagnostic pop
    446             localListener->use(policies);
     445            completionHandler(PolicyAction::Use, WTFMove(policies));
    447446            break;
    448447        }
    … …  
    459458}
    460459
    461 void NavigationState::NavigationClient::decidePolicyForNavigationResponse(WebPageProxy&, API::NavigationResponse& navigationResponse, Ref<WebFramePolicyListenerProxy>&& listener, API::Object* userData)
     460void NavigationState::NavigationClient::decidePolicyForNavigationResponse(WebPageProxy&, API::NavigationResponse& navigationResponse, Function<void(WebCore::PolicyAction, std::optional<WebsitePolicies>&&)>&& completionHandler, API::Object* userData)
    462461{
    463462    if (!m_navigationState.m_navigationDelegateMethods.webViewDecidePolicyForNavigationResponseDecisionHandler) {
    … …  
    468467
    469468            if (exists && !isDirectory && navigationResponse.canShowMIMEType())
    470                 listener->use({ });
     469                completionHandler(PolicyAction::Use, std::nullopt);
    471470            else
    472                 listener->ignore();
     471                completionHandler(PolicyAction::Ignore, std::nullopt);
    473472            return;
    474473        }
    475474
    476475        if (navigationResponse.canShowMIMEType())
    477             listener->use({ });
     476            completionHandler(PolicyAction::Use, std::nullopt);
    478477        else
    479             listener->ignore();
     478            completionHandler(PolicyAction::Ignore, std::nullopt);
    480479        return;
    481480    }
    … …  
    485484        return;
    486485
    487     RefPtr<WebFramePolicyListenerProxy> localListener = WTFMove(listener);
    488     RefPtr<CompletionHandlerCallChecker> checker = CompletionHandlerCallChecker::create(navigationDelegate.get(), @selector(webView:decidePolicyForNavigationResponse:decisionHandler:));
    489     [navigationDelegate webView:m_navigationState.m_webView decidePolicyForNavigationResponse:wrapper(navigationResponse) decisionHandler:[localListener, checker](WKNavigationResponsePolicy responsePolicy) {
     486    auto checker = CompletionHandlerCallChecker::create(navigationDelegate.get(), @selector(webView:decidePolicyForNavigationResponse:decisionHandler:));
     487    [navigationDelegate webView:m_navigationState.m_webView decidePolicyForNavigationResponse:wrapper(navigationResponse) decisionHandler:BlockPtr<void(WKNavigationResponsePolicy)>::fromCallable([completionHandler = WTFMove(completionHandler), checker = WTFMove(checker)](WKNavigationResponsePolicy responsePolicy) {
    490488        if (checker->completionHandlerHasBeenCalled())
    491489            return;
    … …  
    494492        switch (responsePolicy) {
    495493        case WKNavigationResponsePolicyAllow:
    496             localListener->use({ });
     494            completionHandler(PolicyAction::Use, std::nullopt);
    497495            break;
    498496
    499497        case WKNavigationResponsePolicyCancel:
    500             localListener->ignore();
     498            completionHandler(PolicyAction::Ignore, std::nullopt);
    501499            break;
    502500
    … …  
    506504        case _WKNavigationResponsePolicyBecomeDownload:
    507505#pragma clang diagnostic pop
    508             localListener->download();
     506            completionHandler(PolicyAction::Download, std::nullopt);
    509507            break;
    510508        }
    511     }];
     509    }).get()];
    512510}
    513511

  • trunk/Source/WebKit/UIProcess/Cocoa/WebViewImpl.mm

    r222422 r222541  
    3030
    3131#import "APILegacyContextHistoryClient.h"
     32#import "APINavigation.h"
    3233#import "AttributedString.h"
    3334#import "ColorSpaceData.h"

  • trunk/Source/WebKit/UIProcess/RemoteWebInspectorProxy.cpp

    r215683 r222541  
    2727#include "RemoteWebInspectorProxy.h"
    2828
     29#include "APINavigation.h"
    2930#include "RemoteWebInspectorProxyMessages.h"
    3031#include "RemoteWebInspectorUIMessages.h"

  • trunk/Source/WebKit/UIProcess/WebFormSubmissionListenerProxy.h

    r222492 r222541  
    2626#pragma once
    2727
    28 #include "WebFrameListenerProxy.h"
     28#include "APIObject.h"
     29#include <wtf/Function.h>
    2930
    3031namespace WebKit {

  • trunk/Source/WebKit/UIProcess/WebFramePolicyListenerProxy.cpp

    r222492 r222541  
    2727#include "WebFramePolicyListenerProxy.h"
    2828
    29 #include "WebFrameProxy.h"
    3029#include "WebsitePolicies.h"
     30#include <WebCore/FrameLoaderTypes.h>
     31#include <wtf/Function.h>
    3132
    3233namespace WebKit {
    3334
    34 WebFramePolicyListenerProxy::WebFramePolicyListenerProxy(WebFrameProxy* frame, uint64_t listenerID)
    35     : WebFrameListenerProxy(frame, listenerID)
     35Ref<WebFramePolicyListenerProxy> WebFramePolicyListenerProxy::create(Function<void(WebCore::PolicyAction, std::optional<WebsitePolicies>&&)>&& completionHandler)
     36{
     37    return adoptRef(*new WebFramePolicyListenerProxy(WTFMove(completionHandler)));
     38}
     39
     40WebFramePolicyListenerProxy::WebFramePolicyListenerProxy(Function<void(WebCore::PolicyAction, std::optional<WebsitePolicies>&&)>&& completionHandler)
     41    : m_completionHandler(WTFMove(completionHandler))
    3642{
    3743}
    3844
    39 void WebFramePolicyListenerProxy::use(const WebsitePolicies& websitePolicies)
     45void WebFramePolicyListenerProxy::use(std::optional<WebsitePolicies>&& websitePolicies)
    4046{
    41     receivedPolicyDecision(WebCore::PolicyAction::Use, websitePolicies);
     47    if (auto completionHandler = std::exchange(m_completionHandler, nullptr))
     48        completionHandler(WebCore::PolicyAction::Use, WTFMove(websitePolicies));
    4249}
    4350
    4451void WebFramePolicyListenerProxy::download()
    4552{
    46     receivedPolicyDecision(WebCore::PolicyAction::Download, { });
     53    if (auto completionHandler = std::exchange(m_completionHandler, nullptr))
     54        completionHandler(WebCore::PolicyAction::Download, std::nullopt);
    4755}
    4856
    4957void WebFramePolicyListenerProxy::ignore()
    5058{
    51     receivedPolicyDecision(WebCore::PolicyAction::Ignore, { });
     59    if (auto completionHandler = std::exchange(m_completionHandler, nullptr))
     60        completionHandler(WebCore::PolicyAction::Ignore, std::nullopt);
    5261}
    5362

  • trunk/Source/WebKit/UIProcess/WebFramePolicyListenerProxy.h

    r209871 r222541  
    2626#pragma once
    2727
    28 #include "WebFrameListenerProxy.h"
     28#include "APIObject.h"
     29#include <wtf/Function.h>
     30#include <wtf/Optional.h>
    2931
    30 #if PLATFORM(COCOA)
    31 #include "WKFoundation.h"
    32 #endif
    33 
    34 #define DELEGATE_REF_COUNTING_TO_COCOA (PLATFORM(COCOA) && WK_API_ENABLED)
     32namespace WebCore {
     33enum class PolicyAction;
     34}
    3535
    3636namespace WebKit {
    3737
    38 class WebFramePolicyListenerProxy : public WebFrameListenerProxy {
     38struct WebsitePolicies;
     39
     40class WebFramePolicyListenerProxy : public API::ObjectImpl<API::Object::Type::FramePolicyListener> {
    3941public:
    40     static const Type APIType = Type::FramePolicyListener;
     42    static Ref<WebFramePolicyListenerProxy> create(Function<void(WebCore::PolicyAction, std::optional<WebsitePolicies>&&)>&&);
    4143
    42     static Ref<WebFramePolicyListenerProxy> create(WebFrameProxy* frame, uint64_t listenerID)
    43     {
    44         return adoptRef(*new WebFramePolicyListenerProxy(frame, listenerID));
    45     }
    46 
    47     void use(const WebsitePolicies&);
     44    void use(std::optional<WebsitePolicies>&&);
    4845    void download();
    4946    void ignore();
    5047
    5148private:
    52     WebFramePolicyListenerProxy(WebFrameProxy*, uint64_t listenerID);
     49    WebFramePolicyListenerProxy(Function<void(WebCore::PolicyAction, std::optional<WebsitePolicies>&&)>&&);
    5350
    54     Type type() const override { return APIType; }
    55 
    56 #if DELEGATE_REF_COUNTING_TO_COCOA
    57     void* operator new(size_t size) { return newObject(size, APIType); }
    58 #endif
     51    Function<void(WebCore::PolicyAction, std::optional<WebsitePolicies>&&)> m_completionHandler;
    5952};
    6053
    6154} // namespace WebKit
    62 
    63 #undef DELEGATE_REF_COUNTING_TO_COCOA

  • trunk/Source/WebKit/UIProcess/WebFrameProxy.cpp

    r222468 r222541  
    2727#include "WebFrameProxy.h"
    2828
     29#include "APINavigation.h"
    2930#include "WebCertificateInfo.h"
    30 #include "WebFramePolicyListenerProxy.h"
    3131#include "WebPageMessages.h"
    3232#include "WebPageProxy.h"
    … …  
    6161{
    6262    m_page = nullptr;
    63 
    64     if (m_activeListener) {
    65         m_activeListener->invalidate();
    66         m_activeListener = nullptr;
    67     }
    6863}
    6964
    … …  
    174169{
    175170    m_title = title;
    176 }
    177 
    178 void WebFrameProxy::receivedPolicyDecision(PolicyAction action, uint64_t listenerID, API::Navigation* navigation, const WebsitePolicies& websitePolicies)
    179 {
    180     if (!m_page)
    181         return;
    182 
    183     ASSERT(m_activeListener);
    184     ASSERT(m_activeListener->listenerID() == listenerID);
    185     m_page->receivedPolicyDecision(action, *this, listenerID, navigation, websitePolicies);
    186 }
    187 
    188 WebFramePolicyListenerProxy& WebFrameProxy::setUpPolicyListenerProxy(uint64_t listenerID)
    189 {
    190     if (m_activeListener)
    191         m_activeListener->invalidate();
    192     m_activeListener = WebFramePolicyListenerProxy::create(this, listenerID);
    193     return *static_cast<WebFramePolicyListenerProxy*>(m_activeListener.get());
    194171}
    195172

  • trunk/Source/WebKit/UIProcess/WebFrameProxy.h

    r222468 r222541  
    2929#include "FrameLoadState.h"
    3030#include "GenericCallback.h"
    31 #include "WebFrameListenerProxy.h"
    3231#include <WebCore/FrameLoaderTypes.h>
    3332#include <wtf/Forward.h>
    … …  
    5049namespace WebKit {
    5150class WebCertificateInfo;
    52 class WebFramePolicyListenerProxy;
    5351class WebPageProxy;
    5452struct WebsitePolicies;
    … …  
    114112    void didChangeTitle(const String&);
    115113
    116     // Policy operations.
    117     void receivedPolicyDecision(WebCore::PolicyAction, uint64_t listenerID, API::Navigation*, const WebsitePolicies&);
    118     WebFramePolicyListenerProxy& setUpPolicyListenerProxy(uint64_t listenerID);
    119 
    120114#if ENABLE(CONTENT_FILTERING)
    121115    void contentFilterDidBlockLoad(WebCore::ContentFilterUnblockHandler contentFilterUnblockHandler) { m_contentFilterUnblockHandler = WTFMove(contentFilterUnblockHandler); }
    … …  
    139133    bool m_containsPluginDocument { false };
    140134    RefPtr<WebCertificateInfo> m_certificateInfo;
    141     RefPtr<WebFrameListenerProxy> m_activeListener;
    142135    uint64_t m_frameID;
    143136#if ENABLE(CONTENT_FILTERING)

  • trunk/Source/WebKit/UIProcess/WebInspectorProxy.cpp

    r219871 r222541  
    2828#include "WebInspectorProxy.h"
    2929
     30#include "APINavigation.h"
    3031#include "APINavigationAction.h"
    3132#include "APIProcessPoolConfiguration.h"

  • trunk/Source/WebKit/UIProcess/WebPageProxy.cpp

    r222520 r222541  
    5151#include "APIUIClient.h"
    5252#include "APIURLRequest.h"
     53#include "APIWebsitePolicies.h"
    5354#include "AuthenticationChallengeProxy.h"
    5455#include "AuthenticationDecisionListener.h"
    … …  
    8990#include "WebEvent.h"
    9091#include "WebEventConversion.h"
    91 #include "WebFramePolicyListenerProxy.h"
    9292#include "WebFullScreenManagerProxy.h"
    9393#include "WebFullScreenManagerProxyMessages.h"
    … …  
    22582258}
    22592259
    2260 void WebPageProxy::receivedPolicyDecision(PolicyAction action, WebFrameProxy& frame, uint64_t listenerID, API::Navigation* navigation, const WebsitePolicies& websitePolicies)
    2261 {
    2262     if (!isValid())
    2263         return;
    2264 
    2265     auto transaction = m_pageLoadState.transaction();
    2266 
    2267     if (action == PolicyAction::Ignore)
    2268         m_pageLoadState.clearPendingAPIRequestURL(transaction);
    2269 
    2270 #if ENABLE(DOWNLOAD_ATTRIBUTE)
    2271     if (m_syncNavigationActionHasDownloadAttribute && action == PolicyAction::Use)
    2272         action = PolicyAction::Download;
    2273 #endif
    2274 
    2275     DownloadID downloadID = { };
    2276     if (action == PolicyAction::Download) {
    2277         // Create a download proxy.
    2278         auto* download = m_process->processPool().createDownloadProxy(m_decidePolicyForResponseRequest, this);
    2279         if (navigation) {
    2280             download->setWasUserInitiated(navigation->wasUserInitiated());
    2281             download->setRedirectChain(navigation->takeRedirectChain());
    2282         }
    2283 
    2284         downloadID = download->downloadID();
    2285         handleDownloadRequest(download);
    2286         m_decidePolicyForResponseRequest = { };
    2287     }
    2288 
    2289     // If we received a policy decision while in decidePolicyForResponse the decision will
    2290     // be sent back to the web process by decidePolicyForResponse.
    2291     if (m_responsePolicyReply) {
    2292         m_responsePolicyReply->send(action, downloadID);
    2293         ASSERT(!m_newNavigationID);
    2294         m_responsePolicyReply = nullptr;
    2295         return;
    2296     }
    2297 
    2298     // If we received a policy decision while in decidePolicyForNavigationAction the decision will
    2299     // be sent back to the web process by decidePolicyForNavigationAction.
    2300     if (m_navigationActionPolicyReply) {
    2301         m_navigationActionPolicyReply->send(m_newNavigationID, action, downloadID, websitePolicies);
    2302         m_newNavigationID = 0;
    2303         m_navigationActionPolicyReply = nullptr;
    2304         return;
    2305     }
    2306    
    2307     m_process->send(Messages::WebPage::DidReceivePolicyDecision(frame.frameID(), listenerID, action, navigation ? navigation->navigationID() : 0, downloadID), m_pageID);
    2308 }
    2309 
    23102260void WebPageProxy::setUserAgent(const String& userAgent)
    23112261{
    … …  
    36573607}
    36583608
     3609DownloadID WebPageProxy::makeDownloadProxy(ResourceRequest&& request, uint64_t navigationID)
     3610{
     3611    auto* download = m_process->processPool().createDownloadProxy(request, this);
     3612
     3613    RefPtr<API::Navigation> navigation;
     3614    if (navigationID)
     3615        navigation = &m_navigationState->navigation(navigationID);
     3616    else
     3617        navigation = m_navigationState->createLoadRequestNavigation(WTFMove(request));
     3618    download->setWasUserInitiated(navigation->wasUserInitiated());
     3619    download->setRedirectChain(navigation->takeRedirectChain());
     3620    handleDownloadRequest(download);
     3621    return download->downloadID();
     3622}
     3623
    36593624void WebPageProxy::decidePolicyForNavigationAction(uint64_t frameID, const SecurityOriginData& frameSecurityOrigin, uint64_t navigationID, NavigationActionData&& navigationActionData, const FrameInfoData& originatingFrameInfoData, uint64_t originatingPageID, const WebCore::ResourceRequest& originalRequest, ResourceRequest&& request, uint64_t listenerID, const UserData& userData, Ref<Messages::WebPageProxy::DecidePolicyForNavigationAction::DelayedReply>&& reply)
    36603625{
    … …  
    36723637    MESSAGE_CHECK_URL(originalRequest.url());
    36733638   
    3674     m_newNavigationID = 0;
    3675     Ref<WebFramePolicyListenerProxy> listener = frame->setUpPolicyListenerProxy(listenerID);
     3639#if ENABLE(DOWNLOAD_ATTRIBUTE)
     3640    bool forceDownload = !navigationActionData.downloadAttribute.isNull();
     3641#else
     3642    bool forceDownload = false;
     3643#endif
     3644
     3645    uint64_t newNavigationID = 0;
     3646    RefPtr<API::Navigation> navigation;
    36763647    if (!navigationID) {
    3677         auto navigation = m_navigationState->createLoadRequestNavigation(ResourceRequest(request));
    3678         m_newNavigationID = navigation->navigationID();
    3679         navigation->setWasUserInitiated(!!navigationActionData.userGestureTokenIdentifier);
    3680         listener->setNavigation(WTFMove(navigation));
    3681     } else {
    3682         auto& navigation = m_navigationState->navigation(navigationID);
    3683         navigation.setWasUserInitiated(!!navigationActionData.userGestureTokenIdentifier);
    3684         listener->setNavigation(navigation);
    3685     }
     3648        navigation = m_navigationState->createLoadRequestNavigation(ResourceRequest(request));
     3649        newNavigationID = navigation->navigationID();
     3650        navigationID = newNavigationID;
     3651    } else
     3652        navigation = &m_navigationState->navigation(navigationID);
     3653    ASSERT(navigation);
     3654    navigation->setWasUserInitiated(!!navigationActionData.userGestureTokenIdentifier);
     3655
     3656    auto completionHandler = [this, protectedThis = makeRef(*this), reply = WTFMove(reply), request = request, navigationID, newNavigationID, forceDownload](WebCore::PolicyAction policyAction, std::optional<WebsitePolicies>&& optional) mutable {
     3657
     3658        if (policyAction == PolicyAction::Use && forceDownload)
     3659            policyAction = PolicyAction::Download;
     3660
     3661        WebsitePolicies websitePolicies; // FIXME: Just send the optional instead
     3662        if (optional)
     3663            websitePolicies = WTFMove(*optional);
     3664
     3665        DownloadID downloadID;
     3666        switch (policyAction) {
     3667        case PolicyAction::Ignore: {
     3668            auto transaction = m_pageLoadState.transaction();
     3669            m_pageLoadState.clearPendingAPIRequestURL(transaction);
     3670            break;
     3671        }
     3672        case PolicyAction::Download:
     3673            downloadID = makeDownloadProxy(WTFMove(request), navigationID);
     3674            break;
     3675        case PolicyAction::Use:
     3676            break;
     3677        }
     3678        reply->send(newNavigationID, policyAction, downloadID, websitePolicies);
     3679    };
    36863680
    36873681#if ENABLE(CONTENT_FILTERING)
    3688     if (frame->didHandleContentFilterUnblockNavigation(request)) {
    3689         reply->send(m_newNavigationID, PolicyAction::Ignore, { }, { });
    3690         m_newNavigationID = 0;
    3691         return;
    3692     }
    3693 #endif
    3694 
    3695 #if ENABLE(DOWNLOAD_ATTRIBUTE)
    3696     m_syncNavigationActionHasDownloadAttribute = !navigationActionData.downloadAttribute.isNull();
    3697 #endif
    3698     m_navigationActionPolicyReply = WTFMove(reply);
     3682    if (frame->didHandleContentFilterUnblockNavigation(request))
     3683        return completionHandler(PolicyAction::Ignore, std::nullopt);
     3684#endif
    36993685
    37003686    WebFrameProxy* originatingFrame = m_process->webFrame(originatingFrameInfoData.frameID);
    … …  
    37133699        auto navigationAction = API::NavigationAction::create(WTFMove(navigationActionData), sourceFrameInfo.get(), destinationFrameInfo.ptr(), WTFMove(request), originalRequest.url(), shouldOpenAppLinks, WTFMove(userInitiatedActivity));
    37143700
    3715         m_navigationClient->decidePolicyForNavigationAction(*this, WTFMove(navigationAction), WTFMove(listener), m_process->transformHandlesToObjects(userData.object()).get());
     3701        m_navigationClient->decidePolicyForNavigationAction(*this, WTFMove(navigationAction), WTFMove(completionHandler), m_process->transformHandlesToObjects(userData.object()).get());
    37163702    } else
    3717         m_policyClient->decidePolicyForNavigationAction(*this, frame, WTFMove(navigationActionData), originatingFrame, originalRequest, WTFMove(request), WTFMove(listener), m_process->transformHandlesToObjects(userData.object()).get());
     3703        m_policyClient->decidePolicyForNavigationAction(*this, frame, WTFMove(navigationActionData), originatingFrame, originalRequest, WTFMove(request), WTFMove(completionHandler), m_process->transformHandlesToObjects(userData.object()).get());
    37183704
    37193705    m_shouldSuppressAppLinksInNextNavigationPolicyDecision = false;
    … …  
    37273713    MESSAGE_CHECK(frame);
    37283714    MESSAGE_CHECK_URL(request.url());
    3729 
    3730     Ref<WebFramePolicyListenerProxy> listener = frame->setUpPolicyListenerProxy(listenerID);
    37313715
    37323716    if (m_navigationClient) {
    … …  
    37343718        if (frame)
    37353719            sourceFrameInfo = API::FrameInfo::create(*frame, frameSecurityOrigin.securityOrigin());
     3720       
     3721        auto completionHandler = [this, protectedThis = makeRef(*this), listenerID, frameID](WebCore::PolicyAction policyAction, std::optional<WebsitePolicies>&& optional) {
     3722            ASSERT_UNUSED(optional, !optional);
     3723            m_process->send(Messages::WebPage::DidReceivePolicyDecision(frameID, listenerID, policyAction, 0, DownloadID()), m_pageID);
     3724        };
    37363725
    37373726        auto userInitiatedActivity = m_process->userInitiatedActivity(navigationActionData.userGestureTokenIdentifier);
    … …  
    37393728        auto navigationAction = API::NavigationAction::create(WTFMove(navigationActionData), sourceFrameInfo.get(), nullptr, WTFMove(request), request.url(), shouldOpenAppLinks, WTFMove(userInitiatedActivity));
    37403729
    3741         m_navigationClient->decidePolicyForNavigationAction(*this, navigationAction.get(), WTFMove(listener), m_process->transformHandlesToObjects(userData.object()).get());
    3742 
    3743     } else
    3744         m_policyClient->decidePolicyForNewWindowAction(*this, *frame, navigationActionData, request, frameName, WTFMove(listener), m_process->transformHandlesToObjects(userData.object()).get());
    3745 }
    3746 
    3747 void WebPageProxy::decidePolicyForResponse(uint64_t frameID, const SecurityOriginData& frameSecurityOrigin, uint64_t navigationID, const ResourceResponse& response, const ResourceRequest& request, bool canShowMIMEType, uint64_t listenerID, const UserData& userData)
     3730        m_navigationClient->decidePolicyForNavigationAction(*this, navigationAction.get(), WTFMove(completionHandler), m_process->transformHandlesToObjects(userData.object()).get());
     3731
     3732    } else {
     3733        auto completionHandler = [this, protectedThis = makeRef(*this), frameID, listenerID](WebCore::PolicyAction policyAction, std::optional<WebsitePolicies>&& optional) {
     3734            ASSERT_UNUSED(optional, !optional);
     3735            m_process->send(Messages::WebPage::DidReceivePolicyDecision(frameID, listenerID, policyAction, 0, DownloadID()), m_pageID);
     3736        };
     3737        m_policyClient->decidePolicyForNewWindowAction(*this, *frame, navigationActionData, request, frameName, WTFMove(completionHandler), m_process->transformHandlesToObjects(userData.object()).get());
     3738    }
     3739}
     3740
     3741void WebPageProxy::decidePolicyForResponseSync(uint64_t frameID, const SecurityOriginData& frameSecurityOrigin, uint64_t navigationID, const ResourceResponse& response, const ResourceRequest& request, bool canShowMIMEType, uint64_t listenerID, const UserData& userData, Ref<Messages::WebPageProxy::DecidePolicyForResponseSync::DelayedReply>&& reply)
    37483742{
    37493743    PageClientProtector protector(m_pageClient);
    … …  
    37543748    MESSAGE_CHECK_URL(response.url());
    37553749
    3756     Ref<WebFramePolicyListenerProxy> listener = frame->setUpPolicyListenerProxy(listenerID);
    3757     if (navigationID)
    3758         listener->setNavigation(m_navigationState->navigation(navigationID));
     3750    auto completionHandler = [this, protectedThis = makeRef(*this), reply = WTFMove(reply), request = request, navigationID](WebCore::PolicyAction policyAction, std::optional<WebsitePolicies>&& optional) mutable {
     3751        ASSERT_UNUSED(optional, !optional);
     3752        DownloadID downloadID;
     3753        switch (policyAction) {
     3754        case PolicyAction::Ignore: {
     3755            auto transaction = m_pageLoadState.transaction();
     3756            m_pageLoadState.clearPendingAPIRequestURL(transaction);
     3757            break;
     3758        }
     3759        case PolicyAction::Download:
     3760            downloadID = makeDownloadProxy(WTFMove(request), navigationID);
     3761            break;
     3762        case PolicyAction::Use:
     3763            break;
     3764        }
     3765        reply->send(policyAction, downloadID);
     3766    };
    37593767
    37603768    if (m_navigationClient) {
    37613769        auto navigationResponse = API::NavigationResponse::create(API::FrameInfo::create(*frame, frameSecurityOrigin.securityOrigin()).get(), request, response, canShowMIMEType);
    3762         m_navigationClient->decidePolicyForNavigationResponse(*this, navigationResponse.get(), WTFMove(listener), m_process->transformHandlesToObjects(userData.object()).get());
     3770        m_navigationClient->decidePolicyForNavigationResponse(*this, navigationResponse.get(), WTFMove(completionHandler), m_process->transformHandlesToObjects(userData.object()).get());
    37633771    } else
    3764         m_policyClient->decidePolicyForResponse(*this, *frame, response, request, canShowMIMEType, WTFMove(listener), m_process->transformHandlesToObjects(userData.object()).get());
    3765 }
    3766 
    3767 void WebPageProxy::decidePolicyForResponseSync(uint64_t frameID, const SecurityOriginData& frameSecurityOrigin, uint64_t navigationID, const ResourceResponse& response, const ResourceRequest& request, bool canShowMIMEType, uint64_t listenerID, const UserData& userData, Ref<Messages::WebPageProxy::DecidePolicyForResponseSync::DelayedReply>&& reply)
    3768 {
    3769     PageClientProtector protector(m_pageClient);
    3770 
    3771     m_decidePolicyForResponseRequest = request;
    3772     m_responsePolicyReply = WTFMove(reply);
    3773 
    3774     decidePolicyForResponse(frameID, frameSecurityOrigin, navigationID, response, request, canShowMIMEType, listenerID, userData);
     3772        m_policyClient->decidePolicyForResponse(*this, *frame, response, request, canShowMIMEType, WTFMove(completionHandler), m_process->transformHandlesToObjects(userData.object()).get());
    37753773}
    37763774

  • trunk/Source/WebKit/UIProcess/WebPageProxy.h

    r222487 r222541  
    825825#endif
    826826
    827     void receivedPolicyDecision(WebCore::PolicyAction, WebFrameProxy&, uint64_t listenerID, API::Navigation* navigationID, const WebsitePolicies&);
    828 
    829827    void backForwardRemovedItem(uint64_t itemID);
    830828
    … …  
    12661264    void didSameDocumentNavigationForFrame(uint64_t frameID, uint64_t navigationID, uint32_t sameDocumentNavigationType, WebCore::URL&&, const UserData&);
    12671265    void didChangeMainDocument(uint64_t frameID);
     1266    DownloadID makeDownloadProxy(WebCore::ResourceRequest&&, uint64_t navigationID);
    12681267
    12691268    void didReceiveTitleForFrame(uint64_t frameID, const String&, const UserData&);
    … …  
    12861285    void decidePolicyForNavigationAction(uint64_t frameID, const WebCore::SecurityOriginData& frameSecurityOrigin, uint64_t navigationID, NavigationActionData&&, const FrameInfoData&, uint64_t originatingPageID, const WebCore::ResourceRequest& originalRequest, WebCore::ResourceRequest&&, uint64_t listenerID, const UserData&, Ref<Messages::WebPageProxy::DecidePolicyForNavigationAction::DelayedReply>&&);
    12871286    void decidePolicyForNewWindowAction(uint64_t frameID, const WebCore::SecurityOriginData& frameSecurityOrigin, NavigationActionData&&, WebCore::ResourceRequest&&, const String& frameName, uint64_t listenerID, const UserData&);
    1288     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&);
    12891287    void decidePolicyForResponseSync(uint64_t frameID, const WebCore::SecurityOriginData& frameSecurityOrigin, uint64_t navigationID, const WebCore::ResourceResponse&, const WebCore::ResourceRequest&, bool canShowMIMEType, uint64_t listenerID, const UserData&, Ref<Messages::WebPageProxy::DecidePolicyForResponseSync::DelayedReply>&&);
    12901288    void unableToImplementPolicy(uint64_t frameID, const WebCore::ResourceError&, const UserData&);
    … …  
    17991797    bool m_isPerformingDOMPrintOperation { false };
    18001798
    1801     RefPtr<Messages::WebPageProxy::DecidePolicyForNavigationAction::DelayedReply> m_navigationActionPolicyReply;
    1802     uint64_t m_newNavigationID { 0 };
    1803     RefPtr<Messages::WebPageProxy::DecidePolicyForResponseSync::DelayedReply> m_responsePolicyReply;
    1804     WebCore::ResourceRequest m_decidePolicyForResponseRequest;
    1805 
    18061799    bool m_shouldSuppressAppLinksInNextNavigationPolicyDecision { false };
    18071800
    … …  
    20021995#endif
    20031996
    2004 #if ENABLE(DOWNLOAD_ATTRIBUTE)
    2005     bool m_syncNavigationActionHasDownloadAttribute { false };
    2006 #endif
    2007 
    20081997    bool m_isUsingHighPerformanceWebGL { false };
    20091998

  • trunk/Source/WebKit/UIProcess/ios/ViewGestureControllerIOS.mm

    r220506 r222541  
    2929#if PLATFORM(IOS)
    3030
     31#import "APINavigation.h"
    3132#import "DrawingAreaProxy.h"
    3233#import "UIKitSPI.h"

  • trunk/Source/WebKit/UIProcess/mac/ViewGestureControllerMac.mm

    r220979 r222541  
    2929#if PLATFORM(MAC)
    3030
     31#import "APINavigation.h"
    3132#import "DrawingAreaProxy.h"
    3233#import "FrameLoadState.h"

  • trunk/Source/WebKit/WebKit.xcodeproj/project.pbxproj

    r222183 r222541  
    18591859                BCE469591214EDF4000B98EB /* WKFormSubmissionListener.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BCE469571214EDF4000B98EB /* WKFormSubmissionListener.cpp */; };
    18601860                BCE4695A1214EDF4000B98EB /* WKFormSubmissionListener.h in Headers */ = {isa = PBXBuildFile; fileRef = BCE469581214EDF4000B98EB /* WKFormSubmissionListener.h */; settings = {ATTRIBUTES = (Private, ); }; };
    1861                 BCE469771214F27B000B98EB /* WebFrameListenerProxy.h in Headers */ = {isa = PBXBuildFile; fileRef = BCE469761214F27B000B98EB /* WebFrameListenerProxy.h */; };
    1862                 BCE469791214F2B4000B98EB /* WebFrameListenerProxy.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BCE469781214F2B4000B98EB /* WebFrameListenerProxy.cpp */; };
    18631861                BCE81D8C1319F7EF00241910 /* FontInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BCE81D8A1319F7EF00241910 /* FontInfo.cpp */; };
    18641862                BCE81D8D1319F7EF00241910 /* FontInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = BCE81D8B1319F7EF00241910 /* FontInfo.h */; };
    … …  
    42424240                BCE469571214EDF4000B98EB /* WKFormSubmissionListener.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WKFormSubmissionListener.cpp; sourceTree = "<group>"; };
    42434241                BCE469581214EDF4000B98EB /* WKFormSubmissionListener.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WKFormSubmissionListener.h; sourceTree = "<group>"; };
    4244                 BCE469761214F27B000B98EB /* WebFrameListenerProxy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebFrameListenerProxy.h; sourceTree = "<group>"; };
    4245                 BCE469781214F2B4000B98EB /* WebFrameListenerProxy.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebFrameListenerProxy.cpp; sourceTree = "<group>"; };
    42464242                BCE81D8A1319F7EF00241910 /* FontInfo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FontInfo.cpp; sourceTree = "<group>"; };
    42474243                BCE81D8B1319F7EF00241910 /* FontInfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FontInfo.h; sourceTree = "<group>"; };
    … …  
    69846980                                BCE469511214E6CB000B98EB /* WebFormSubmissionListenerProxy.cpp */,
    69856981                                BCE469521214E6CB000B98EB /* WebFormSubmissionListenerProxy.h */,
    6986                                 BCE469781214F2B4000B98EB /* WebFrameListenerProxy.cpp */,
    6987                                 BCE469761214F27B000B98EB /* WebFrameListenerProxy.h */,
    69886982                                BCB9F69F1123A84B00A137E0 /* WebFramePolicyListenerProxy.cpp */,
    69896983                                BCB9F69E1123A84B00A137E0 /* WebFramePolicyListenerProxy.h */,
    … …  
    88728866                                BCE469561214E6CB000B98EB /* WebFormSubmissionListenerProxy.h in Headers */,
    88738867                                BC032D8D10F437A00058C15A /* WebFrame.h in Headers */,
    8874                                 BCE469771214F27B000B98EB /* WebFrameListenerProxy.h in Headers */,
    88758868                                BC032D7F10F4378D0058C15A /* WebFrameLoaderClient.h in Headers */,
    88768869                                9391F2CB121B67AD00EBF7E8 /* WebFrameNetworkingContext.h in Headers */,
    … …  
    1048210475                                BCE469551214E6CB000B98EB /* WebFormSubmissionListenerProxy.cpp in Sources */,
    1048310476                                BC111ADD112F5B9300337BAB /* WebFrame.cpp in Sources */,
    10484                                 BCE469791214F2B4000B98EB /* WebFrameListenerProxy.cpp in Sources */,
    1048510477                                BC111A5F112F4FBB00337BAB /* WebFrameLoaderClient.cpp in Sources */,
    1048610478                                2D28F3E71885CCC1004B9EAE /* WebFrameLoaderClientIOS.mm in Sources */,
Note: See TracChangeset for help on using the changeset viewer.