Changeset 235559 in webkit


Ignore:
Timestamp:
Aug 31, 2018 10:41:32 AM (6 years ago)
Author:
Chris Dumez
Message:

Rename ShouldProcessSwapIfPossible to ProcessSwapRequestedByClient for clarity
​https://bugs.webkit.org/show_bug.cgi?id=189195

Reviewed by Alex Christensen.

Rename ShouldProcessSwapIfPossible to ProcessSwapRequestedByClient for clarity, since it indicates the client
requested a process swap via its navigation policy decision.

  • UIProcess/API/C/WKFramePolicyListener.cpp:

(WKFramePolicyListenerUseInNewProcess):
(useWithPolicies):
(WKFramePolicyListenerUseWithPolicies):
(WKFramePolicyListenerUseInNewProcessWithPolicies):

  • UIProcess/Cocoa/NavigationState.mm:

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

  • UIProcess/WebFramePolicyListenerProxy.cpp:

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

  • UIProcess/WebFramePolicyListenerProxy.h:
  • UIProcess/WebFrameProxy.cpp:

(WebKit::WebFrameProxy::setUpPolicyListenerProxy):

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

(WebKit::WebPageProxy::decidePolicyForNavigationAction):
(WebKit::WebPageProxy::decidePolicyForNewWindowAction):
(WebKit::WebPageProxy::decidePolicyForResponse):

  • UIProcess/WebPageProxy.h:
  • UIProcess/WebProcessPool.cpp:

(WebKit::WebProcessPool::processForNavigation):
(WebKit::WebProcessPool::processForNavigationInternal):

  • UIProcess/WebProcessPool.h:
Location:
trunk/Source/WebKit
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit/ChangeLog

    r235556 r235559  
     12018-08-31  Chris Dumez  <cdumez@apple.com>
     2
     3        Rename ShouldProcessSwapIfPossible to ProcessSwapRequestedByClient for clarity
     4        https://bugs.webkit.org/show_bug.cgi?id=189195
     5
     6        Reviewed by Alex Christensen.
     7
     8        Rename ShouldProcessSwapIfPossible to ProcessSwapRequestedByClient for clarity, since it indicates the client
     9        requested a process swap via its navigation policy decision.
     10
     11        * UIProcess/API/C/WKFramePolicyListener.cpp:
     12        (WKFramePolicyListenerUseInNewProcess):
     13        (useWithPolicies):
     14        (WKFramePolicyListenerUseWithPolicies):
     15        (WKFramePolicyListenerUseInNewProcessWithPolicies):
     16        * UIProcess/Cocoa/NavigationState.mm:
     17        (WebKit::NavigationState::NavigationClient::decidePolicyForNavigationAction):
     18        * UIProcess/WebFramePolicyListenerProxy.cpp:
     19        (WebKit::WebFramePolicyListenerProxy::use):
     20        (WebKit::WebFramePolicyListenerProxy::download):
     21        (WebKit::WebFramePolicyListenerProxy::ignore):
     22        * UIProcess/WebFramePolicyListenerProxy.h:
     23        * UIProcess/WebFrameProxy.cpp:
     24        (WebKit::WebFrameProxy::setUpPolicyListenerProxy):
     25        * UIProcess/WebFrameProxy.h:
     26        * UIProcess/WebPageProxy.cpp:
     27        (WebKit::WebPageProxy::decidePolicyForNavigationAction):
     28        (WebKit::WebPageProxy::decidePolicyForNewWindowAction):
     29        (WebKit::WebPageProxy::decidePolicyForResponse):
     30        * UIProcess/WebPageProxy.h:
     31        * UIProcess/WebProcessPool.cpp:
     32        (WebKit::WebProcessPool::processForNavigation):
     33        (WebKit::WebProcessPool::processForNavigationInternal):
     34        * UIProcess/WebProcessPool.h:
     35
    1362018-08-31  Aditya Keerthi  <akeerthi@apple.com>
    237

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

    r234168 r235559  
    4949void WKFramePolicyListenerUseInNewProcess(WKFramePolicyListenerRef policyListenerRef)
    5050{
    51     toImpl(policyListenerRef)->use(nullptr, ShouldProcessSwapIfPossible::Yes);
     51    toImpl(policyListenerRef)->use(nullptr, ProcessSwapRequestedByClient::Yes);
    5252}
    5353
    54 static void useWithPolicies(WKFramePolicyListenerRef policyListenerRef, WKWebsitePoliciesRef websitePolicies, ShouldProcessSwapIfPossible shouldProcessSwapIfPossible)
     54static void useWithPolicies(WKFramePolicyListenerRef policyListenerRef, WKWebsitePoliciesRef websitePolicies, ProcessSwapRequestedByClient processSwapRequestedByClient)
    5555{
    5656    if (auto* websiteDataStore = toImpl(websitePolicies)->websiteDataStore()) {
    … …  
    5959    }
    6060
    61     toImpl(policyListenerRef)->use(toImpl(websitePolicies), shouldProcessSwapIfPossible);
     61    toImpl(policyListenerRef)->use(toImpl(websitePolicies), processSwapRequestedByClient);
    6262}
    6363
    6464void WKFramePolicyListenerUseWithPolicies(WKFramePolicyListenerRef policyListenerRef, WKWebsitePoliciesRef websitePolicies)
    6565{
    66     useWithPolicies(policyListenerRef, websitePolicies, ShouldProcessSwapIfPossible::No);
     66    useWithPolicies(policyListenerRef, websitePolicies, ProcessSwapRequestedByClient::No);
    6767}
    6868
    6969void WKFramePolicyListenerUseInNewProcessWithPolicies(WKFramePolicyListenerRef policyListenerRef, WKWebsitePoliciesRef websitePolicies)
    7070{
    71     useWithPolicies(policyListenerRef, websitePolicies, ShouldProcessSwapIfPossible::Yes);
     71    useWithPolicies(policyListenerRef, websitePolicies, ProcessSwapRequestedByClient::Yes);
    7272}
    7373

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

    r235365 r235559  
    553553                }
    554554
    555                 localListener->use(websitePolicies.get(), actionPolicy == _WKNavigationActionPolicyAllowInNewProcess ? ShouldProcessSwapIfPossible::Yes : ShouldProcessSwapIfPossible::No);
     555                localListener->use(websitePolicies.get(), actionPolicy == _WKNavigationActionPolicyAllowInNewProcess ? ProcessSwapRequestedByClient::Yes : ProcessSwapRequestedByClient::No);
    556556            });
    557557       

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

    r234658 r235559  
    5656}
    5757
    58 void WebFramePolicyListenerProxy::use(API::WebsitePolicies* policies, ShouldProcessSwapIfPossible swap)
     58void WebFramePolicyListenerProxy::use(API::WebsitePolicies* policies, ProcessSwapRequestedByClient processSwapRequestedByClient)
    5959{
    6060    if (m_safeBrowsingResults) {
    6161        if (m_reply)
    62             m_reply(WebCore::PolicyAction::Use, policies, swap, WTFMove(*m_safeBrowsingResults));
     62            m_reply(WebCore::PolicyAction::Use, policies, processSwapRequestedByClient, WTFMove(*m_safeBrowsingResults));
    6363    } else if (!m_policyResult)
    64         m_policyResult = {{ policies, swap }};
     64        m_policyResult = {{ policies, processSwapRequestedByClient }};
    6565}
    6666
    … …  
    6868{
    6969    if (m_reply)
    70         m_reply(WebCore::PolicyAction::Download, nullptr, ShouldProcessSwapIfPossible::No, { });
     70        m_reply(WebCore::PolicyAction::Download, nullptr, ProcessSwapRequestedByClient::No, { });
    7171}
    7272
    … …  
    7474{
    7575    if (m_reply)
    76         m_reply(WebCore::PolicyAction::Ignore, nullptr, ShouldProcessSwapIfPossible::No, { });
     76        m_reply(WebCore::PolicyAction::Ignore, nullptr, ProcessSwapRequestedByClient::No, { });
    7777}
    7878

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

    r234640 r235559  
    4242class SafeBrowsingResult;
    4343
    44 enum class ShouldProcessSwapIfPossible { No, Yes };
     44enum class ProcessSwapRequestedByClient { No, Yes };
    4545enum class ShouldExpectSafeBrowsingResult { No, Yes };
    4646
    … …  
    4848public:
    4949
    50     using Reply = CompletionHandler<void(WebCore::PolicyAction, API::WebsitePolicies*, ShouldProcessSwapIfPossible, Vector<SafeBrowsingResult>&&)>;
     50    using Reply = CompletionHandler<void(WebCore::PolicyAction, API::WebsitePolicies*, ProcessSwapRequestedByClient, Vector<SafeBrowsingResult>&&)>;
    5151    static Ref<WebFramePolicyListenerProxy> create(Reply&& reply, ShouldExpectSafeBrowsingResult expect)
    5252    {
    … …  
    5555    ~WebFramePolicyListenerProxy();
    5656
    57     void use(API::WebsitePolicies* = nullptr, ShouldProcessSwapIfPossible = ShouldProcessSwapIfPossible::No);
     57    void use(API::WebsitePolicies* = nullptr, ProcessSwapRequestedByClient = ProcessSwapRequestedByClient::No);
    5858    void download();
    5959    void ignore();
    … …  
    6464    WebFramePolicyListenerProxy(Reply&&, ShouldExpectSafeBrowsingResult);
    6565
    66     std::optional<std::pair<RefPtr<API::WebsitePolicies>, ShouldProcessSwapIfPossible>> m_policyResult;
     66    std::optional<std::pair<RefPtr<API::WebsitePolicies>, ProcessSwapRequestedByClient>> m_policyResult;
    6767    std::optional<Vector<SafeBrowsingResult>> m_safeBrowsingResults;
    6868    Reply m_reply;

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

    r235265 r235559  
    178178}
    179179
    180 WebFramePolicyListenerProxy& WebFrameProxy::setUpPolicyListenerProxy(CompletionHandler<void(WebCore::PolicyAction, API::WebsitePolicies*, ShouldProcessSwapIfPossible, Vector<SafeBrowsingResult>&&)>&& completionHandler, ShouldExpectSafeBrowsingResult expect)
     180WebFramePolicyListenerProxy& WebFrameProxy::setUpPolicyListenerProxy(CompletionHandler<void(WebCore::PolicyAction, API::WebsitePolicies*, ProcessSwapRequestedByClient, Vector<SafeBrowsingResult>&&)>&& completionHandler, ShouldExpectSafeBrowsingResult expect)
    181181{
    182182    if (m_activeListener)
    183183        m_activeListener->ignore();
    184     m_activeListener = WebFramePolicyListenerProxy::create([this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)] (WebCore::PolicyAction action, API::WebsitePolicies* policies, ShouldProcessSwapIfPossible swap, Vector<SafeBrowsingResult>&& safeBrowsingResults) mutable {
    185         completionHandler(action, policies, swap, WTFMove(safeBrowsingResults));
     184    m_activeListener = WebFramePolicyListenerProxy::create([this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)] (WebCore::PolicyAction action, API::WebsitePolicies* policies, ProcessSwapRequestedByClient processSwapRequestedByClient, Vector<SafeBrowsingResult>&& safeBrowsingResults) mutable {
     185        completionHandler(action, policies, processSwapRequestedByClient, WTFMove(safeBrowsingResults));
    186186        m_activeListener = nullptr;
    187187    }, expect);

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

    r234640 r235559  
    5555class WebsiteDataStore;
    5656enum class ShouldExpectSafeBrowsingResult;
    57 enum class ShouldProcessSwapIfPossible;
     57enum class ProcessSwapRequestedByClient;
    5858struct WebsitePoliciesData;
    5959
    … …  
    118118    void didChangeTitle(const String&);
    119119
    120     WebFramePolicyListenerProxy& setUpPolicyListenerProxy(CompletionHandler<void(WebCore::PolicyAction, API::WebsitePolicies*, ShouldProcessSwapIfPossible, Vector<SafeBrowsingResult>&&)>&&, ShouldExpectSafeBrowsingResult);
     120    WebFramePolicyListenerProxy& setUpPolicyListenerProxy(CompletionHandler<void(WebCore::PolicyAction, API::WebsitePolicies*, ProcessSwapRequestedByClient, Vector<SafeBrowsingResult>&&)>&&, ShouldExpectSafeBrowsingResult);
    121121
    122122#if ENABLE(CONTENT_FILTERING)

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

    r235556 r235559  
    40144014#endif
    40154015
    4016     auto listener = makeRef(frame->setUpPolicyListenerProxy([this, protectedThis = makeRef(*this), frame = makeRef(*frame), sender = sender.copyRef(), navigation] (WebCore::PolicyAction policyAction, API::WebsitePolicies* policies, ShouldProcessSwapIfPossible swap, Vector<SafeBrowsingResult>&&) mutable {
     4016    auto listener = makeRef(frame->setUpPolicyListenerProxy([this, protectedThis = makeRef(*this), frame = makeRef(*frame), sender = sender.copyRef(), navigation] (WebCore::PolicyAction policyAction, API::WebsitePolicies* policies, ProcessSwapRequestedByClient processSwapRequestedByClient, Vector<SafeBrowsingResult>&&) mutable {
    40174017        // FIXME: do something with the SafeBrowsingResults.
    40184018
    … …  
    40254025
    40264026        if (policyAction == PolicyAction::Use && frame->isMainFrame()) {
    4027             auto proposedProcess = process().processPool().processForNavigation(*this, *navigation, swap, policyAction);
     4027            auto proposedProcess = process().processPool().processForNavigation(*this, *navigation, processSwapRequestedByClient, policyAction);
    40284028           
    40294029            if (proposedProcess.ptr() != &process()) {
    … …  
    40854085    MESSAGE_CHECK_URL(request.url());
    40864086
    4087     auto listener = makeRef(frame->setUpPolicyListenerProxy([this, protectedThis = makeRef(*this), listenerID, frameID] (WebCore::PolicyAction policyAction, API::WebsitePolicies*, ShouldProcessSwapIfPossible swap, Vector<SafeBrowsingResult>&& safeBrowsingResults) mutable {
     4087    auto listener = makeRef(frame->setUpPolicyListenerProxy([this, protectedThis = makeRef(*this), listenerID, frameID] (WebCore::PolicyAction policyAction, API::WebsitePolicies*, ProcessSwapRequestedByClient processSwapRequestedByClient, Vector<SafeBrowsingResult>&& safeBrowsingResults) mutable {
    40884088        // FIXME: Assert the API::WebsitePolicies* is nullptr here once clients of WKFramePolicyListenerUseWithPolicies go away.
    4089         RELEASE_ASSERT(swap == ShouldProcessSwapIfPossible::No);
     4089        RELEASE_ASSERT(processSwapRequestedByClient == ProcessSwapRequestedByClient::No);
    40904090        ASSERT_UNUSED(safeBrowsingResults, safeBrowsingResults.isEmpty());
    40914091        receivedPolicyDecision(policyAction, nullptr, std::nullopt, PolicyDecisionSender::create([this, protectedThis = WTFMove(protectedThis), frameID, listenerID] (auto... args) {
    … …  
    41214121
    41224122    RefPtr<API::Navigation> navigation = navigationID ? &m_navigationState->navigation(navigationID) : nullptr;
    4123     auto listener = makeRef(frame->setUpPolicyListenerProxy([this, protectedThis = makeRef(*this), frameID, listenerID, navigation = WTFMove(navigation)] (WebCore::PolicyAction policyAction, API::WebsitePolicies*, ShouldProcessSwapIfPossible swap, Vector<SafeBrowsingResult>&& safeBrowsingResults) mutable {
     4123    auto listener = makeRef(frame->setUpPolicyListenerProxy([this, protectedThis = makeRef(*this), frameID, listenerID, navigation = WTFMove(navigation)] (WebCore::PolicyAction policyAction, API::WebsitePolicies*, ProcessSwapRequestedByClient processSwapRequestedByClient, Vector<SafeBrowsingResult>&& safeBrowsingResults) mutable {
    41244124        // FIXME: Assert the API::WebsitePolicies* is nullptr here once clients of WKFramePolicyListenerUseWithPolicies go away.
    4125         RELEASE_ASSERT(swap == ShouldProcessSwapIfPossible::No);
     4125        RELEASE_ASSERT(processSwapRequestedByClient == ProcessSwapRequestedByClient::No);
    41264126        ASSERT_UNUSED(safeBrowsingResults, safeBrowsingResults.isEmpty());
    41274127        receivedPolicyDecision(policyAction, navigation.get(), std::nullopt, PolicyDecisionSender::create([this, protectedThis = WTFMove(protectedThis), frameID, listenerID] (auto... args) {

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

    r235556 r235559  
    259259struct URLSchemeTaskParameters;
    260260
    261 enum class ShouldProcessSwapIfPossible;
     261enum class ProcessSwapRequestedByClient;
    262262enum class UndoOrRedo;
    263263

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

    r235513 r235559  
    21272127}
    21282128
    2129 Ref<WebProcessProxy> WebProcessPool::processForNavigation(WebPageProxy& page, const API::Navigation& navigation, ShouldProcessSwapIfPossible shouldProcessSwapIfPossible, PolicyAction& action)
    2130 {
    2131     auto process = processForNavigationInternal(page, navigation, shouldProcessSwapIfPossible, action);
     2129Ref<WebProcessProxy> WebProcessPool::processForNavigation(WebPageProxy& page, const API::Navigation& navigation, ProcessSwapRequestedByClient processSwapRequestedByClient, PolicyAction& action)
     2130{
     2131    auto process = processForNavigationInternal(page, navigation, processSwapRequestedByClient, action);
    21322132
    21332133    if (m_configuration->alwaysKeepAndReuseSwappedProcesses() && process.ptr() != &page.process()) {
    … …  
    21452145}
    21462146
    2147 Ref<WebProcessProxy> WebProcessPool::processForNavigationInternal(WebPageProxy& page, const API::Navigation& navigation, ShouldProcessSwapIfPossible shouldProcessSwapIfPossible, PolicyAction& action)
    2148 {
    2149     if (!m_configuration->processSwapsOnNavigation() && shouldProcessSwapIfPossible == ShouldProcessSwapIfPossible::No)
     2147Ref<WebProcessProxy> WebProcessPool::processForNavigationInternal(WebPageProxy& page, const API::Navigation& navigation, ProcessSwapRequestedByClient processSwapRequestedByClient, PolicyAction& action)
     2148{
     2149    if (!m_configuration->processSwapsOnNavigation() && processSwapRequestedByClient == ProcessSwapRequestedByClient::No)
    21502150        return page.process();
    21512151
    … …  
    21912191
    21922192    auto targetURL = navigation.currentRequest().url();
    2193     if (shouldProcessSwapIfPossible == ShouldProcessSwapIfPossible::No) {
     2193    if (processSwapRequestedByClient == ProcessSwapRequestedByClient::No) {
    21942194        if (navigation.treatAsSameOriginNavigation())
    21952195            return page.process();

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

    r235481 r235559  
    111111#endif
    112112
    113 enum class ShouldProcessSwapIfPossible;
     113enum class ProcessSwapRequestedByClient;
    114114
    115115class WebProcessPool final : public API::ObjectImpl<API::Object::Type::ProcessPool>, public CanMakeWeakPtr<WebProcessPool>, private IPC::MessageReceiver {
    … …  
    451451#endif
    452452
    453     Ref<WebProcessProxy> processForNavigation(WebPageProxy&, const API::Navigation&, ShouldProcessSwapIfPossible, WebCore::PolicyAction&);
     453    Ref<WebProcessProxy> processForNavigation(WebPageProxy&, const API::Navigation&, ProcessSwapRequestedByClient, WebCore::PolicyAction&);
    454454    void registerSuspendedPageProxy(SuspendedPageProxy&);
    455455    void unregisterSuspendedPageProxy(SuspendedPageProxy&);
    … …  
    471471    void platformInvalidateContext();
    472472
    473     Ref<WebProcessProxy> processForNavigationInternal(WebPageProxy&, const API::Navigation&, ShouldProcessSwapIfPossible, WebCore::PolicyAction&);
     473    Ref<WebProcessProxy> processForNavigationInternal(WebPageProxy&, const API::Navigation&, ProcessSwapRequestedByClient, WebCore::PolicyAction&);
    474474
    475475    RefPtr<WebProcessProxy> tryTakePrewarmedProcess(WebsiteDataStore&);
Note: See TracChangeset for help on using the changeset viewer.