Changeset 260890 in webkit


Ignore:
Timestamp:
Apr 29, 2020 3:23:01 AM (4 years ago)
Author:
commit-queue@webkit.org
Message:

Make PolicyChecker an inner class of FrameLoader
​https://bugs.webkit.org/show_bug.cgi?id=211138

Patch by Rob Buis <​rbuis@igalia.com> on 2020-04-29
Reviewed by Alex Christensen.

Source/WebCore:

PolicyChecker HistoryController an inner class of FrameLoader, this allows us to move some methods
only used by PolicyChecker out of the FrameLoader public API. Because it is not possible to forward declare
an enum class in an inner class, move ShouldContinue out of the PolicyChecker class and rename it
to ShouldContinuePolicyCheck.

  • loader/FrameLoader.cpp:

(WebCore::FrameLoader::loadURL):
(WebCore::FrameLoader::load):
(WebCore::FrameLoader::loadPostRequest):
(WebCore::FrameLoader::continueLoadAfterNewWindowPolicy):

  • loader/FrameLoader.h:
  • loader/FrameLoaderTypes.h:
  • loader/MediaResourceLoader.cpp:

(WebCore::MediaResource::responseReceived):

  • loader/PolicyChecker.cpp:
  • loader/PolicyChecker.h:
  • platform/graphics/PlatformMediaResourceLoader.h:

(WebCore::PlatformMediaResourceClient::responseReceived):

  • platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm:

(WebCore::PlatformResourceMediaLoader::responseReceived):

  • platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:

(CachedResourceStreamingClient::responseReceived):

  • platform/network/cocoa/WebCoreNSURLSession.mm:

(WebCore::WebCoreNSURLSessionDataTaskClient::responseReceived):
(-[WebCoreNSURLSessionDataTask resource:receivedResponse:completionHandler:]):

Source/WebKit:

Adapt to PolicyChecker::ShouldContinue change.

  • GPUProcess/media/RemoteMediaResource.cpp:

(WebKit::RemoteMediaResource::responseReceived):

  • GPUProcess/media/RemoteMediaResource.h:
  • GPUProcess/media/RemoteMediaResourceManager.cpp:

(WebKit::RemoteMediaResourceManager::responseReceived):

  • GPUProcess/media/RemoteMediaResourceManager.h:
  • GPUProcess/media/RemoteMediaResourceManager.messages.in:
  • Scripts/webkit/messages.py:
  • WebProcess/GPU/media/RemoteMediaResourceProxy.cpp:

(WebKit::RemoteMediaResourceProxy::responseReceived):

  • WebProcess/GPU/media/RemoteMediaResourceProxy.h:
Location:
trunk/Source
Files:
20 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r260889 r260890  
     12020-04-29  Rob Buis  <rbuis@igalia.com>
     2
     3        Make PolicyChecker an inner class of FrameLoader
     4        https://bugs.webkit.org/show_bug.cgi?id=211138
     5
     6        Reviewed by Alex Christensen.
     7
     8        PolicyChecker HistoryController an inner class of FrameLoader, this allows us to move some methods
     9        only used by PolicyChecker out of the FrameLoader public API. Because it is not possible to forward declare
     10        an enum class in an inner class, move ShouldContinue out of the PolicyChecker class and rename it
     11        to ShouldContinuePolicyCheck.
     12
     13        * loader/FrameLoader.cpp:
     14        (WebCore::FrameLoader::loadURL):
     15        (WebCore::FrameLoader::load):
     16        (WebCore::FrameLoader::loadPostRequest):
     17        (WebCore::FrameLoader::continueLoadAfterNewWindowPolicy):
     18        * loader/FrameLoader.h:
     19        * loader/FrameLoaderTypes.h:
     20        * loader/MediaResourceLoader.cpp:
     21        (WebCore::MediaResource::responseReceived):
     22        * loader/PolicyChecker.cpp:
     23        * loader/PolicyChecker.h:
     24        * platform/graphics/PlatformMediaResourceLoader.h:
     25        (WebCore::PlatformMediaResourceClient::responseReceived):
     26        * platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm:
     27        (WebCore::PlatformResourceMediaLoader::responseReceived):
     28        * platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:
     29        (CachedResourceStreamingClient::responseReceived):
     30        * platform/network/cocoa/WebCoreNSURLSession.mm:
     31        (WebCore::WebCoreNSURLSessionDataTaskClient::responseReceived):
     32        (-[WebCoreNSURLSessionDataTask resource:receivedResponse:completionHandler:]):
     33
    1342020-04-29  Adrian Perez de Castro  <aperez@igalia.com>
    235

  • trunk/Source/WebCore/loader/FrameLoader.cpp

    r260843 r260890  
    13851385    if (!targetFrame && !effectiveFrameName.isEmpty()) {
    13861386        action = action.copyWithShouldOpenExternalURLsPolicy(shouldOpenExternalURLsPolicyToApply(m_frame, frameLoadRequest));
    1387         policyChecker().checkNewWindowPolicy(WTFMove(action), WTFMove(request), WTFMove(formState), effectiveFrameName, [this, allowNavigationToInvalidURL, openerPolicy, completionHandler = completionHandlerCaller.release()] (const ResourceRequest& request, WeakPtr<FormState>&& formState, const String& frameName, const NavigationAction& action, PolicyChecker::ShouldContinue shouldContinue) mutable {
     1387        policyChecker().checkNewWindowPolicy(WTFMove(action), WTFMove(request), WTFMove(formState), effectiveFrameName, [this, allowNavigationToInvalidURL, openerPolicy, completionHandler = completionHandlerCaller.release()] (const ResourceRequest& request, WeakPtr<FormState>&& formState, const String& frameName, const NavigationAction& action, ShouldContinuePolicyCheck shouldContinue) mutable {
    13881388            continueLoadAfterNewWindowPolicy(request, formState.get(), frameName, action, shouldContinue, allowNavigationToInvalidURL, openerPolicy);
    13891389            completionHandler();
    … …  
    14681468    if (request.shouldCheckNewWindowPolicy()) {
    14691469        NavigationAction action { request.requester(), request.resourceRequest(), InitiatedByMainFrame::Unknown, NavigationType::Other, request.shouldOpenExternalURLsPolicy() };
    1470         policyChecker().checkNewWindowPolicy(WTFMove(action), WTFMove(request.resourceRequest()), { }, request.frameName(), [this] (const ResourceRequest& request, WeakPtr<FormState>&& formState, const String& frameName, const NavigationAction& action, PolicyChecker::ShouldContinue shouldContinue) {
     1470        policyChecker().checkNewWindowPolicy(WTFMove(action), WTFMove(request.resourceRequest()), { }, request.frameName(), [this] (const ResourceRequest& request, WeakPtr<FormState>&& formState, const String& frameName, const NavigationAction& action, ShouldContinuePolicyCheck shouldContinue) {
    14711471            continueLoadAfterNewWindowPolicy(request, formState.get(), frameName, action, shouldContinue, AllowNavigationToInvalidURL::Yes, NewFrameOpenerPolicy::Suppress);
    14721472        });
    … …  
    30223022        }
    30233023
    3024         policyChecker().checkNewWindowPolicy(WTFMove(action), WTFMove(workingResourceRequest), WTFMove(formState), frameName, [this, allowNavigationToInvalidURL, openerPolicy, completionHandler = WTFMove(completionHandler)] (const ResourceRequest& request, WeakPtr<FormState>&& formState, const String& frameName, const NavigationAction& action, PolicyChecker::ShouldContinue shouldContinue) mutable {
     3024        policyChecker().checkNewWindowPolicy(WTFMove(action), WTFMove(workingResourceRequest), WTFMove(formState), frameName, [this, allowNavigationToInvalidURL, openerPolicy, completionHandler = WTFMove(completionHandler)] (const ResourceRequest& request, WeakPtr<FormState>&& formState, const String& frameName, const NavigationAction& action, ShouldContinuePolicyCheck shouldContinue) mutable {
    30253025            continueLoadAfterNewWindowPolicy(request, formState.get(), frameName, action, shouldContinue, allowNavigationToInvalidURL, openerPolicy);
    30263026            completionHandler();
    … …  
    35013501
    35023502void FrameLoader::continueLoadAfterNewWindowPolicy(const ResourceRequest& request,
    3503     FormState* formState, const String& frameName, const NavigationAction& action, PolicyChecker::ShouldContinue shouldContinue, AllowNavigationToInvalidURL allowNavigationToInvalidURL, NewFrameOpenerPolicy openerPolicy)
    3504 {
    3505     if (shouldContinue != PolicyChecker::ShouldContinue::Yes)
     3503    FormState* formState, const String& frameName, const NavigationAction& action, ShouldContinuePolicyCheck shouldContinue, AllowNavigationToInvalidURL allowNavigationToInvalidURL, NewFrameOpenerPolicy openerPolicy)
     3504{
     3505    if (shouldContinue != ShouldContinuePolicyCheck::Yes)
    35063506        return;
    35073507

  • trunk/Source/WebCore/loader/FrameLoader.h

    r260843 r260890  
    4040#include "MixedContentChecker.h"
    4141#include "PageIdentifier.h"
    42 #include "PolicyChecker.h"
    4342#include "ReferrerPolicy.h"
    4443#include "ResourceLoadNotifier.h"
    … …  
    7877class Node;
    7978class Page;
    80 class PolicyChecker;
    8179class ResourceError;
    8280class ResourceRequest;
    … …  
    111109    Frame& frame() const { return m_frame; }
    112110
     111    class PolicyChecker;
    113112    PolicyChecker& policyChecker() const { return *m_policyChecker; }
    114113
    … …  
    157156    void closeURL();
    158157    void cancelAndClear();
    159     void clearProvisionalLoadForPolicyCheck();
    160158    // FIXME: clear() is trying to do too many things. We should break it down into smaller functions (ideally with fewer raw Boolean parameters).
    161159    void clear(Document* newDocument, bool clearWindowProperties = true, bool clearScriptObjects = true, bool clearFrameView = true, WTF::Function<void()>&& handleDOMWindowCreation = nullptr);
    … …  
    257255    WEBCORE_EXPORT void setOpener(Frame*);
    258256    WEBCORE_EXPORT void detachFromAllOpenedFrames();
    259     bool hasOpenedFrames() const { return !m_openedFrames.isEmpty(); }
    260257
    261258    void resetMultipleFormSubmissionProtection();
    … …  
    364361
    365362    void continueLoadAfterNavigationPolicy(const ResourceRequest&, FormState*, NavigationPolicyDecision, AllowNavigationToInvalidURL);
    366     void continueLoadAfterNewWindowPolicy(const ResourceRequest&, FormState*, const String& frameName, const NavigationAction&, PolicyChecker::ShouldContinue, AllowNavigationToInvalidURL, NewFrameOpenerPolicy);
     363    void continueLoadAfterNewWindowPolicy(const ResourceRequest&, FormState*, const String& frameName, const NavigationAction&, ShouldContinuePolicyCheck, AllowNavigationToInvalidURL, NewFrameOpenerPolicy);
    367364    void continueFragmentScrollAfterNavigationPolicy(const ResourceRequest&, bool shouldContinue);
    368365
    … …  
    430427    void loadURLIntoChildFrame(const URL&, const String& referer, Frame*);
    431428    void started();
     429
     430    // PolicyChecker specific.
     431    void clearProvisionalLoadForPolicyCheck();
     432    bool hasOpenedFrames() const { return !m_openedFrames.isEmpty(); }
    432433
    433434    Frame& m_frame;

  • trunk/Source/WebCore/loader/FrameLoaderTypes.h

    r257707 r260890  
    113113}
    114114
     115enum class ShouldContinuePolicyCheck : bool {
     116    Yes,
     117    No
     118};
     119
    115120enum class NewFrameOpenerPolicy : uint8_t {
    116121    Suppress,

  • trunk/Source/WebCore/loader/MediaResourceLoader.cpp

    r257655 r260890  
    183183            if (completionHandler)
    184184                completionHandler();
    185             if (shouldContinue == PolicyChecker::ShouldContinue::No)
     185            if (shouldContinue == ShouldContinuePolicyCheck::No)
    186186                stop();
    187187        });

  • trunk/Source/WebCore/loader/PolicyChecker.cpp

    r259752 r260890  
    9292}
    9393
    94 PolicyChecker::PolicyChecker(Frame& frame)
     94FrameLoader::PolicyChecker::PolicyChecker(Frame& frame)
    9595    : m_frame(frame)
    9696    , m_delegateIsDecidingNavigationPolicy(false)
    … …  
    100100}
    101101
    102 void PolicyChecker::checkNavigationPolicy(ResourceRequest&& newRequest, const ResourceResponse& redirectResponse, NavigationPolicyDecisionFunction&& function)
     102void FrameLoader::PolicyChecker::checkNavigationPolicy(ResourceRequest&& newRequest, const ResourceResponse& redirectResponse, NavigationPolicyDecisionFunction&& function)
    103103{
    104104    checkNavigationPolicy(WTFMove(newRequest), redirectResponse, m_frame.loader().activeDocumentLoader(), { }, WTFMove(function));
    105105}
    106106
    107 CompletionHandlerCallingScope PolicyChecker::extendBlobURLLifetimeIfNecessary(ResourceRequest& request) const
     107CompletionHandlerCallingScope FrameLoader::PolicyChecker::extendBlobURLLifetimeIfNecessary(ResourceRequest& request) const
    108108{
    109109    if (!request.url().protocolIsBlob())
    … …  
    119119}
    120120
    121 void PolicyChecker::checkNavigationPolicy(ResourceRequest&& request, const ResourceResponse& redirectResponse, DocumentLoader* loader, RefPtr<FormState>&& formState, NavigationPolicyDecisionFunction&& function, PolicyDecisionMode policyDecisionMode)
     121void FrameLoader::PolicyChecker::checkNavigationPolicy(ResourceRequest&& request, const ResourceResponse& redirectResponse, DocumentLoader* loader, RefPtr<FormState>&& formState, NavigationPolicyDecisionFunction&& function, PolicyDecisionMode policyDecisionMode)
    122122{
    123123    NavigationAction action = loader->triggeringAction();
    … …  
    248248}
    249249
    250 void PolicyChecker::checkNewWindowPolicy(NavigationAction&& navigationAction, ResourceRequest&& request, RefPtr<FormState>&& formState, const String& frameName, NewWindowPolicyDecisionFunction&& function)
     250void FrameLoader::PolicyChecker::checkNewWindowPolicy(NavigationAction&& navigationAction, ResourceRequest&& request, RefPtr<FormState>&& formState, const String& frameName, NewWindowPolicyDecisionFunction&& function)
    251251{
    252252    if (m_frame.document() && m_frame.document()->isSandboxed(SandboxPopups))
    253         return function({ }, nullptr, { }, { }, ShouldContinue::No);
     253        return function({ }, nullptr, { }, { }, ShouldContinuePolicyCheck::No);
    254254
    255255    if (!DOMWindow::allowPopUp(m_frame))
    256         return function({ }, nullptr, { }, { }, ShouldContinue::No);
     256        return function({ }, nullptr, { }, { }, ShouldContinuePolicyCheck::No);
    257257
    258258    auto blobURLLifetimeExtension = extendBlobURLLifetimeIfNecessary(request);
    … …  
    264264
    265265        if (!responseIdentifier.isValidFor(requestIdentifier))
    266             return function({ }, nullptr, { }, { }, ShouldContinue::No);
     266            return function({ }, nullptr, { }, { }, ShouldContinuePolicyCheck::No);
    267267
    268268        switch (policyAction) {
    … …  
    271271            FALLTHROUGH;
    272272        case PolicyAction::Ignore:
    273             function({ }, nullptr, { }, { }, ShouldContinue::No);
     273            function({ }, nullptr, { }, { }, ShouldContinuePolicyCheck::No);
    274274            return;
    275275        case PolicyAction::StopAllLoads:
    276276            ASSERT_NOT_REACHED();
    277             function({ }, nullptr, { }, { }, ShouldContinue::No);
     277            function({ }, nullptr, { }, { }, ShouldContinuePolicyCheck::No);
    278278            return;
    279279        case PolicyAction::Use:
    280             function(request, makeWeakPtr(formState.get()), frameName, navigationAction, ShouldContinue::Yes);
     280            function(request, makeWeakPtr(formState.get()), frameName, navigationAction, ShouldContinuePolicyCheck::Yes);
    281281            return;
    282282        }
    … …  
    285285}
    286286
    287 void PolicyChecker::stopCheck()
     287void FrameLoader::PolicyChecker::stopCheck()
    288288{
    289289    m_frame.loader().client().cancelPolicyCheck();
    290290}
    291291
    292 void PolicyChecker::cannotShowMIMEType(const ResourceResponse& response)
     292void FrameLoader::PolicyChecker::cannotShowMIMEType(const ResourceResponse& response)
    293293{
    294294    handleUnimplementablePolicy(m_frame.loader().client().cannotShowMIMETypeError(response));
    295295}
    296296
    297 void PolicyChecker::handleUnimplementablePolicy(const ResourceError& error)
     297void FrameLoader::PolicyChecker::handleUnimplementablePolicy(const ResourceError& error)
    298298{
    299299    m_delegateIsHandlingUnimplementablePolicy = true;

  • trunk/Source/WebCore/loader/PolicyChecker.h

    r253964 r260890  
    3030#pragma once
    3131
    32 #include "FrameLoaderTypes.h"
     32#include "FrameLoader.h"
    3333#include "ResourceRequest.h"
    3434#include <wtf/WeakPtr.h>
    … …  
    6161enum class PolicyDecisionMode { Synchronous, Asynchronous };
    6262
    63 class PolicyChecker {
     63class FrameLoader::PolicyChecker {
    6464    WTF_MAKE_NONCOPYABLE(PolicyChecker);
    6565    WTF_MAKE_FAST_ALLOCATED;
    … …  
    6767    explicit PolicyChecker(Frame&);
    6868
    69     enum class ShouldContinue {
    70         Yes,
    71         No
    72     };
    73 
    7469    using NavigationPolicyDecisionFunction = CompletionHandler<void(ResourceRequest&&, WeakPtr<FormState>&&, NavigationPolicyDecision)>;
    75     using NewWindowPolicyDecisionFunction = CompletionHandler<void(const ResourceRequest&, WeakPtr<FormState>&&, const String& frameName, const NavigationAction&, ShouldContinue)>;
     70    using NewWindowPolicyDecisionFunction = CompletionHandler<void(const ResourceRequest&, WeakPtr<FormState>&&, const String& frameName, const NavigationAction&, ShouldContinuePolicyCheck)>;
    7671
    7772    void checkNavigationPolicy(ResourceRequest&&, const ResourceResponse& redirectResponse, DocumentLoader*, RefPtr<FormState>&&, NavigationPolicyDecisionFunction&&, PolicyDecisionMode = PolicyDecisionMode::Asynchronous);
    … …  
    113108
    114109} // namespace WebCore
    115 
    116 // To support encoding WebCore::PolicyChecker::ShouldContinue in XPC messages
    117 namespace WTF {
    118 
    119 template<> struct EnumTraits<WebCore::PolicyChecker::ShouldContinue> {
    120     using values = EnumValues<
    121         WebCore::PolicyChecker::ShouldContinue,
    122         WebCore::PolicyChecker::ShouldContinue::No,
    123         WebCore::PolicyChecker::ShouldContinue::Yes
    124     >;
    125 };
    126 
    127 }

  • trunk/Source/WebCore/platform/graphics/PlatformMediaResourceLoader.h

    r253964 r260890  
    4545    virtual ~PlatformMediaResourceClient() = default;
    4646
    47     virtual void responseReceived(PlatformMediaResource&, const ResourceResponse&, CompletionHandler<void(PolicyChecker::ShouldContinue)>&& completionHandler) { completionHandler(PolicyChecker::ShouldContinue::Yes); }
     47    virtual void responseReceived(PlatformMediaResource&, const ResourceResponse&, CompletionHandler<void(ShouldContinuePolicyCheck)>&& completionHandler) { completionHandler(ShouldContinuePolicyCheck::Yes); }
    4848    virtual void redirectReceived(PlatformMediaResource&, ResourceRequest&& request, const ResourceResponse&, CompletionHandler<void(ResourceRequest&&)>&& completionHandler) { completionHandler(WTFMove(request)); }
    4949    virtual bool shouldCacheResponse(PlatformMediaResource&, const ResourceResponse&) { return true; }

  • trunk/Source/WebCore/platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm

    r255347 r260890  
    144144
    145145    // PlatformMediaResourceClient
    146     void responseReceived(PlatformMediaResource&, const ResourceResponse&, CompletionHandler<void(PolicyChecker::ShouldContinue)>&&) final;
     146    void responseReceived(PlatformMediaResource&, const ResourceResponse&, CompletionHandler<void(ShouldContinuePolicyCheck)>&&) final;
    147147    void redirectReceived(PlatformMediaResource&, ResourceRequest&& request, const ResourceResponse&, CompletionHandler<void(ResourceRequest&&)>&& completionHandler) final { completionHandler(WTFMove(request)); }
    148148    bool shouldCacheResponse(PlatformMediaResource&, const ResourceResponse&) final { return false; }
    … …  
    187187}
    188188
    189 void PlatformResourceMediaLoader::responseReceived(PlatformMediaResource&, const ResourceResponse& response, CompletionHandler<void(PolicyChecker::ShouldContinue)>&& completionHandler)
     189void PlatformResourceMediaLoader::responseReceived(PlatformMediaResource&, const ResourceResponse& response, CompletionHandler<void(ShouldContinuePolicyCheck)>&& completionHandler)
    190190{
    191191    m_parent.responseReceived(response);
    192     completionHandler(PolicyChecker::ShouldContinue::Yes);
     192    completionHandler(ShouldContinuePolicyCheck::Yes);
    193193}
    194194

  • trunk/Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp

    r260755 r260890  
    6969
    7070    // PlatformMediaResourceClient virtual methods.
    71     void responseReceived(PlatformMediaResource&, const ResourceResponse&, CompletionHandler<void(PolicyChecker::ShouldContinue)>&&) override;
     71    void responseReceived(PlatformMediaResource&, const ResourceResponse&, CompletionHandler<void(ShouldContinuePolicyCheck)>&&) override;
    7272    void dataReceived(PlatformMediaResource&, const char*, int) override;
    7373    void accessControlCheckFailed(PlatformMediaResource&, const ResourceError&) override;
    … …  
    993993}
    994994
    995 void CachedResourceStreamingClient::responseReceived(PlatformMediaResource&, const ResourceResponse& response, CompletionHandler<void(PolicyChecker::ShouldContinue)>&& completionHandler)
     995void CachedResourceStreamingClient::responseReceived(PlatformMediaResource&, const ResourceResponse& response, CompletionHandler<void(ShouldContinuePolicyCheck)>&& completionHandler)
    996996{
    997997    ASSERT(isMainThread());
    … …  
    10001000    DataMutex<WebKitWebSrcPrivate::StreamingMembers>::LockedWrapper members(priv->dataMutex);
    10011001    if (members->requestNumber != m_requestNumber) {
    1002         completionHandler(PolicyChecker::ShouldContinue::No);
     1002        completionHandler(ShouldContinuePolicyCheck::No);
    10031003        return;
    10041004    }
    … …  
    10521052        members->doesHaveEOS = true;
    10531053        members->responseCondition.notifyOne();
    1054         completionHandler(PolicyChecker::ShouldContinue::No);
     1054        completionHandler(ShouldContinuePolicyCheck::No);
    10551055        return;
    10561056    }
    … …  
    10631063            members->doesHaveEOS = true;
    10641064            members->responseCondition.notifyOne();
    1065             completionHandler(PolicyChecker::ShouldContinue::No);
     1065            completionHandler(ShouldContinuePolicyCheck::No);
    10661066            return;
    10671067        }
    … …  
    11021102    members->responseCondition.notifyOne();
    11031103
    1104     completionHandler(PolicyChecker::ShouldContinue::Yes);
     1104    completionHandler(ShouldContinuePolicyCheck::Yes);
    11051105}
    11061106

  • trunk/Source/WebCore/platform/network/cocoa/WebCoreNSURLSession.mm

    r260485 r260890  
    5858
    5959- (void)resource:(PlatformMediaResource&)resource sentBytes:(unsigned long long)bytesSent totalBytesToBeSent:(unsigned long long)totalBytesToBeSent;
    60 - (void)resource:(PlatformMediaResource&)resource receivedResponse:(const ResourceResponse&)response completionHandler:(CompletionHandler<void(PolicyChecker::ShouldContinue)>&&)completionHandler;
     60- (void)resource:(PlatformMediaResource&)resource receivedResponse:(const ResourceResponse&)response completionHandler:(CompletionHandler<void(ShouldContinuePolicyCheck)>&&)completionHandler;
    6161- (BOOL)resource:(PlatformMediaResource&)resource shouldCacheResponse:(const ResourceResponse&)response;
    6262- (void)resource:(PlatformMediaResource&)resource receivedData:(const char*)data length:(int)length;
    … …  
    383383    void clearTask();
    384384
    385     void responseReceived(PlatformMediaResource&, const ResourceResponse&, CompletionHandler<void(PolicyChecker::ShouldContinue)>&&) override;
     385    void responseReceived(PlatformMediaResource&, const ResourceResponse&, CompletionHandler<void(ShouldContinuePolicyCheck)>&&) override;
    386386    void redirectReceived(PlatformMediaResource&, ResourceRequest&&, const ResourceResponse&, CompletionHandler<void(ResourceRequest&&)>&&) override;
    387387    bool shouldCacheResponse(PlatformMediaResource&, const ResourceResponse&) override;
    … …  
    412412}
    413413
    414 void WebCoreNSURLSessionDataTaskClient::responseReceived(PlatformMediaResource& resource, const ResourceResponse& response, CompletionHandler<void(PolicyChecker::ShouldContinue)>&& completionHandler)
     414void WebCoreNSURLSessionDataTaskClient::responseReceived(PlatformMediaResource& resource, const ResourceResponse& response, CompletionHandler<void(ShouldContinuePolicyCheck)>&& completionHandler)
    415415{
    416416    LockHolder locker(m_taskLock);
    417417    if (!m_task)
    418         return completionHandler(PolicyChecker::ShouldContinue::No);
     418        return completionHandler(ShouldContinuePolicyCheck::No);
    419419
    420420    [m_task resource:resource receivedResponse:response completionHandler:WTFMove(completionHandler)];
    … …  
    629629}
    630630
    631 - (void)resource:(PlatformMediaResource&)resource receivedResponse:(const ResourceResponse&)response completionHandler:(CompletionHandler<void(PolicyChecker::ShouldContinue)>&&)completionHandler
     631- (void)resource:(PlatformMediaResource&)resource receivedResponse:(const ResourceResponse&)response completionHandler:(CompletionHandler<void(ShouldContinuePolicyCheck)>&&)completionHandler
    632632{
    633633    ASSERT(response.source() == ResourceResponse::Source::Network || response.source() == ResourceResponse::Source::DiskCache || response.source() == ResourceResponse::Source::DiskCacheAfterValidation || response.source() == ResourceResponse::Source::ServiceWorker);
    … …  
    640640    RetainPtr<WebCoreNSURLSessionDataTask> strongSelf { self };
    641641    if (!self.session)
    642         return completionHandler(PolicyChecker::ShouldContinue::No);
     642        return completionHandler(ShouldContinuePolicyCheck::No);
    643643    [self.session addDelegateOperation:[strongSelf, strongResponse, completionHandler = WTFMove(completionHandler)] () mutable {
    644644        strongSelf->_response = strongResponse.get();
    … …  
    647647        if (![dataDelegate respondsToSelector:@selector(URLSession:dataTask:didReceiveResponse:completionHandler:)]) {
    648648            callOnMainThread([strongSelf, completionHandler = WTFMove(completionHandler)] () mutable {
    649                 completionHandler(PolicyChecker::ShouldContinue::Yes);
     649                completionHandler(ShouldContinuePolicyCheck::Yes);
    650650            });
    651651            return;
    … …  
    655655            callOnMainThread([strongSelf, disposition, completionHandler = WTFMove(completionHandler)] () mutable {
    656656                if (disposition == NSURLSessionResponseCancel)
    657                     completionHandler(PolicyChecker::ShouldContinue::No);
     657                    completionHandler(ShouldContinuePolicyCheck::No);
    658658                else {
    659659                    ASSERT(disposition == NSURLSessionResponseAllow);
    660                     completionHandler(PolicyChecker::ShouldContinue::Yes);
     660                    completionHandler(ShouldContinuePolicyCheck::Yes);
    661661                }
    662662            });

  • trunk/Source/WebKit/ChangeLog

    r260889 r260890  
     12020-04-29  Rob Buis  <rbuis@igalia.com>
     2
     3        Make PolicyChecker an inner class of FrameLoader
     4        https://bugs.webkit.org/show_bug.cgi?id=211138
     5
     6        Reviewed by Alex Christensen.
     7
     8        Adapt to PolicyChecker::ShouldContinue change.
     9
     10        * GPUProcess/media/RemoteMediaResource.cpp:
     11        (WebKit::RemoteMediaResource::responseReceived):
     12        * GPUProcess/media/RemoteMediaResource.h:
     13        * GPUProcess/media/RemoteMediaResourceManager.cpp:
     14        (WebKit::RemoteMediaResourceManager::responseReceived):
     15        * GPUProcess/media/RemoteMediaResourceManager.h:
     16        * GPUProcess/media/RemoteMediaResourceManager.messages.in:
     17        * Scripts/webkit/messages.py:
     18        * WebProcess/GPU/media/RemoteMediaResourceProxy.cpp:
     19        (WebKit::RemoteMediaResourceProxy::responseReceived):
     20        * WebProcess/GPU/media/RemoteMediaResourceProxy.h:
     21
    1222020-04-29  Adrian Perez de Castro  <aperez@igalia.com>
    223

  • trunk/Source/WebKit/GPUProcess/media/RemoteMediaResource.cpp

    r253964 r260890  
    6767}
    6868
    69 void RemoteMediaResource::responseReceived(const ResourceResponse& response, bool didPassAccessControlCheck, CompletionHandler<void(PolicyChecker::ShouldContinue)>&& completionHandler)
     69void RemoteMediaResource::responseReceived(const ResourceResponse& response, bool didPassAccessControlCheck, CompletionHandler<void(ShouldContinuePolicyCheck)>&& completionHandler)
    7070{
    7171    if (!m_client)
    … …  
    7575    m_client->responseReceived(*this, response, [protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](auto shouldContinue) mutable {
    7676        ASSERT(isMainThread());
    77         if (shouldContinue == PolicyChecker::ShouldContinue::No)
     77        if (shouldContinue == ShouldContinuePolicyCheck::No)
    7878            protectedThis->stop();
    7979

  • trunk/Source/WebKit/GPUProcess/media/RemoteMediaResource.h

    r253964 r260890  
    4949    bool didPassAccessControlCheck() const final;
    5050
    51     void responseReceived(const WebCore::ResourceResponse&, bool, CompletionHandler<void(WebCore::PolicyChecker::ShouldContinue)>&&);
     51    void responseReceived(const WebCore::ResourceResponse&, bool, CompletionHandler<void(WebCore::ShouldContinuePolicyCheck)>&&);
    5252    void redirectReceived(WebCore::ResourceRequest&&, const WebCore::ResourceResponse&, CompletionHandler<void(WebCore::ResourceRequest&&)>&&);
    5353    void dataSent(uint64_t, uint64_t);

  • trunk/Source/WebKit/GPUProcess/media/RemoteMediaResourceManager.cpp

    r254809 r260890  
    6060}
    6161
    62 void RemoteMediaResourceManager::responseReceived(RemoteMediaResourceIdentifier id, const ResourceResponse& response, bool didPassAccessControlCheck, CompletionHandler<void(PolicyChecker::ShouldContinue)>&& completionHandler)
     62void RemoteMediaResourceManager::responseReceived(RemoteMediaResourceIdentifier id, const ResourceResponse& response, bool didPassAccessControlCheck, CompletionHandler<void(ShouldContinuePolicyCheck)>&& completionHandler)
    6363{
    6464    auto* resource = m_remoteMediaResources.get(id);
    6565    if (!resource || !resource->ready()) {
    66         completionHandler(PolicyChecker::ShouldContinue::No);
     66        completionHandler(ShouldContinuePolicyCheck::No);
    6767        return;
    6868    }

  • trunk/Source/WebKit/GPUProcess/media/RemoteMediaResourceManager.h

    r253964 r260890  
    6161
    6262private:
    63     void responseReceived(RemoteMediaResourceIdentifier, const WebCore::ResourceResponse&, bool, CompletionHandler<void(WebCore::PolicyChecker::ShouldContinue)>&&);
     63    void responseReceived(RemoteMediaResourceIdentifier, const WebCore::ResourceResponse&, bool, CompletionHandler<void(WebCore::ShouldContinuePolicyCheck)>&&);
    6464    void redirectReceived(RemoteMediaResourceIdentifier, WebCore::ResourceRequest&&, const WebCore::ResourceResponse&, CompletionHandler<void(WebCore::ResourceRequest&&)>&&);
    6565    void dataSent(RemoteMediaResourceIdentifier, uint64_t, uint64_t);

  • trunk/Source/WebKit/GPUProcess/media/RemoteMediaResourceManager.messages.in

    r253964 r260890  
    2727
    2828messages -> RemoteMediaResourceManager NotRefCounted {
    29     ResponseReceived(WebKit::RemoteMediaResourceIdentifier id, WebCore::ResourceResponse response, bool didPassAccessControlCheck) -> (WebCore::PolicyChecker::ShouldContinue shouldContinue) Async
     29    ResponseReceived(WebKit::RemoteMediaResourceIdentifier id, WebCore::ResourceResponse response, bool didPassAccessControlCheck) -> (enum:bool WebCore::ShouldContinuePolicyCheck shouldContinue) Async
    3030    RedirectReceived(WebKit::RemoteMediaResourceIdentifier id, WebCore::ResourceRequest request, WebCore::ResourceResponse response) -> (WebCore::ResourceRequest returnRequest) Async
    3131    DataSent(WebKit::RemoteMediaResourceIdentifier id, uint64_t bytesSent, uint64_t totalBytesToBeSent)

  • trunk/Source/WebKit/Scripts/webkit/messages.py

    r260718 r260890  
    608608        'WebCore::PluginInfo': ['<WebCore/PluginData.h>'],
    609609        'WebCore::PolicyAction': ['<WebCore/FrameLoaderTypes.h>'],
     610        'WebCore::ShouldContinuePolicyCheck': ['<WebCore/FrameLoaderTypes.h>'],
    610611        'WebCore::PolicyCheckIdentifier': ['<WebCore/FrameLoaderTypes.h>'],
    611612        'WebCore::ProcessIdentifier': ['<WebCore/ProcessIdentifier.h>'],

  • trunk/Source/WebKit/WebProcess/GPU/media/RemoteMediaResourceProxy.cpp

    r253964 r260890  
    4747}
    4848
    49 void RemoteMediaResourceProxy::responseReceived(WebCore::PlatformMediaResource&, const WebCore::ResourceResponse& response, CompletionHandler<void(WebCore::PolicyChecker::ShouldContinue)>&& completionHandler)
     49void RemoteMediaResourceProxy::responseReceived(WebCore::PlatformMediaResource&, const WebCore::ResourceResponse& response, CompletionHandler<void(WebCore::ShouldContinuePolicyCheck)>&& completionHandler)
    5050{
    5151    m_connection->sendWithAsyncReply(Messages::RemoteMediaResourceManager::ResponseReceived(m_id, response, m_platformMediaResource.didPassAccessControlCheck()), [completionHandler = WTFMove(completionHandler)](auto shouldContinue) mutable {

  • trunk/Source/WebKit/WebProcess/GPU/media/RemoteMediaResourceProxy.h

    r253964 r260890  
    4444private:
    4545    // PlatformMediaResourceClient
    46     void responseReceived(WebCore::PlatformMediaResource&, const WebCore::ResourceResponse&, CompletionHandler<void(WebCore::PolicyChecker::ShouldContinue)>&&) final;
     46    void responseReceived(WebCore::PlatformMediaResource&, const WebCore::ResourceResponse&, CompletionHandler<void(WebCore::ShouldContinuePolicyCheck)>&&) final;
    4747    void redirectReceived(WebCore::PlatformMediaResource&, WebCore::ResourceRequest&&, const WebCore::ResourceResponse&, CompletionHandler<void(WebCore::ResourceRequest&&)>&&) final;
    4848    bool shouldCacheResponse(WebCore::PlatformMediaResource&, const WebCore::ResourceResponse&) final;
Note: See TracChangeset for help on using the changeset viewer.