Changeset 240015 in webkit


Ignore:
Timestamp:
Jan 15, 2019 3:48:31 PM (5 years ago)
Author:
Chris Dumez
Message:

Unreviewed, rolling out r239993, r239995, r239997, and
r239999.

Caused assertions under
ViewGestureController::disconnectFromProcess()

Reverted changesets:

"Regression(PSON) View becomes blank after click a cross-site
download link"
https://bugs.webkit.org/show_bug.cgi?id=193361
https://trac.webkit.org/changeset/239993

"Unreviewed iOS build fix after r239993."
https://trac.webkit.org/changeset/239995

"Fix iOS build after r239993"
https://bugs.webkit.org/show_bug.cgi?id=193361
https://trac.webkit.org/changeset/239997

"Unreviewed, revert part of r239997 as it is not needed to fix
the build."
https://trac.webkit.org/changeset/239999

Location:
trunk
Files:
2 deleted
24 edited

Legend:

Unmodified
Added
Removed
  • trunk/LayoutTests/ChangeLog

    r239993 r240015  
     12019-01-15  Chris Dumez  <cdumez@apple.com>
     2
     3        Unreviewed, rolling out r239993, r239995, r239997, and
     4        r239999.
     5
     6        Caused assertions under
     7        ViewGestureController::disconnectFromProcess()
     8
     9        Reverted changesets:
     10
     11        "Regression(PSON) View becomes blank after click a cross-site
     12        download link"
     13        https://bugs.webkit.org/show_bug.cgi?id=193361
     14        https://trac.webkit.org/changeset/239993
     15
     16        "Unreviewed iOS build fix after r239993."
     17        https://trac.webkit.org/changeset/239995
     18
     19        "Fix iOS build after r239993"
     20        https://bugs.webkit.org/show_bug.cgi?id=193361
     21        https://trac.webkit.org/changeset/239997
     22
     23        "Unreviewed, revert part of r239997 as it is not needed to fix
     24        the build."
     25        https://trac.webkit.org/changeset/239999
     26
    1272019-01-15  Chris Dumez  <cdumez@apple.com>
    228
  • trunk/LayoutTests/platform/wk2/TestExpectations

    r239993 r240015  
    734734http/tests/resourceLoadStatistics/cap-cache-max-age-for-prevalent-resource.html [ Skip ]
    735735
    736 # This feature is currently disabled by default and unfinished <rdar://problem/38925077>.
    737 http/tests/navigation/process-swap-window-open.html [ Skip ]
     736# Process swapping is only implemented on WebKit2.
     737http/tests/navigation/process-swap-window-open.html [ Pass ]
    738738
    739739# Cross-Origin-Resource-Policy response header is only implemented in WebKit2.
  • trunk/Source/WebCore/ChangeLog

    r240014 r240015  
     12019-01-15  Chris Dumez  <cdumez@apple.com>
     2
     3        Unreviewed, rolling out r239993, r239995, r239997, and
     4        r239999.
     5
     6        Caused assertions under
     7        ViewGestureController::disconnectFromProcess()
     8
     9        Reverted changesets:
     10
     11        "Regression(PSON) View becomes blank after click a cross-site
     12        download link"
     13        https://bugs.webkit.org/show_bug.cgi?id=193361
     14        https://trac.webkit.org/changeset/239993
     15
     16        "Unreviewed iOS build fix after r239993."
     17        https://trac.webkit.org/changeset/239995
     18
     19        "Fix iOS build after r239993"
     20        https://bugs.webkit.org/show_bug.cgi?id=193361
     21        https://trac.webkit.org/changeset/239997
     22
     23        "Unreviewed, revert part of r239997 as it is not needed to fix
     24        the build."
     25        https://trac.webkit.org/changeset/239999
     26
    1272019-01-15  Alex Christensen  <achristensen@webkit.org>
    228
  • trunk/Source/WebCore/loader/FrameLoader.cpp

    r239993 r240015  
    20332033        Optional<HasInsecureContent> hasInsecureContent = cachedPage->cachedMainFrame()->hasInsecureContent();
    20342034
    2035         dispatchDidCommitLoad(hasInsecureContent);
    2036 
    20372035        // FIXME: This API should be turned around so that we ground CachedPage into the Page.
    20382036        cachedPage->restore(*m_frame.page());
     2037
     2038        dispatchDidCommitLoad(hasInsecureContent);
    20392039
    20402040#if PLATFORM(IOS_FAMILY)
  • trunk/Source/WebKit/ChangeLog

    r240014 r240015  
     12019-01-15  Chris Dumez  <cdumez@apple.com>
     2
     3        Unreviewed, rolling out r239993, r239995, r239997, and
     4        r239999.
     5
     6        Caused assertions under
     7        ViewGestureController::disconnectFromProcess()
     8
     9        Reverted changesets:
     10
     11        "Regression(PSON) View becomes blank after click a cross-site
     12        download link"
     13        https://bugs.webkit.org/show_bug.cgi?id=193361
     14        https://trac.webkit.org/changeset/239993
     15
     16        "Unreviewed iOS build fix after r239993."
     17        https://trac.webkit.org/changeset/239995
     18
     19        "Fix iOS build after r239993"
     20        https://bugs.webkit.org/show_bug.cgi?id=193361
     21        https://trac.webkit.org/changeset/239997
     22
     23        "Unreviewed, revert part of r239997 as it is not needed to fix
     24        the build."
     25        https://trac.webkit.org/changeset/239999
     26
    1272019-01-15  Alex Christensen  <achristensen@webkit.org>
    228
  • trunk/Source/WebKit/Shared/WebPageCreationParameters.cpp

    r239993 r240015  
    7474    encoder << mimeTypesWithCustomContentProviders;
    7575    encoder << controlledByAutomation;
    76     encoder << isProcessSwap;
     76    encoder << isSwapFromSuspended;
    7777
    7878#if PLATFORM(MAC)
     
    228228    if (!decoder.decode(parameters.controlledByAutomation))
    229229        return WTF::nullopt;
    230     if (!decoder.decode(parameters.isProcessSwap))
     230    if (!decoder.decode(parameters.isSwapFromSuspended))
    231231        return WTF::nullopt;
    232232
  • trunk/Source/WebKit/Shared/WebPageCreationParameters.h

    r239993 r240015  
    130130
    131131    bool controlledByAutomation;
    132     bool isProcessSwap { false };
     132    bool isSwapFromSuspended { false };
    133133
    134134#if PLATFORM(MAC)
  • trunk/Source/WebKit/Shared/WebPolicyAction.h

    r239993 r240015  
    3030namespace WebKit {
    3131
    32 // FIXME: Remove this type and use WebCore::PolicyAction instead.
    3332enum class WebPolicyAction : uint8_t {
    3433    Use,
    3534    Download,
    36     Ignore
     35    Ignore,
     36    Suspend
    3737};
    3838
     
    4646        WebKit::WebPolicyAction::Use,
    4747        WebKit::WebPolicyAction::Download,
    48         WebKit::WebPolicyAction::Ignore
     48        WebKit::WebPolicyAction::Ignore,
     49        WebKit::WebPolicyAction::Suspend
    4950    >;
    5051};
  • trunk/Source/WebKit/Sources.txt

    r240014 r240015  
    231231UIProcess/ProcessAssertion.cpp
    232232UIProcess/ProcessThrottler.cpp
    233 UIProcess/ProvisionalPageProxy.cpp
    234233UIProcess/RemoteWebInspectorProxy.cpp
    235234UIProcess/ResponsivenessTimer.cpp
  • trunk/Source/WebKit/UIProcess/API/Cocoa/WKWebView.mm

    r239993 r240015  
    4545#import "ObjCObjectGraph.h"
    4646#import "PageClient.h"
    47 #import "ProvisionalPageProxy.h"
    4847#import "RemoteLayerTreeScrollingPerformanceData.h"
    4948#import "RemoteLayerTreeTransaction.h"
     
    47024701    Ref<WebKit::WebProcessProxy> protectedProcessProxy(_page->process());
    47034702    protectedProcessProxy->requestTermination(WebKit::ProcessTerminationReason::RequestedByClient);
    4704 
    4705     if (auto* provisionalPageProxy = _page->provisionalPageProxy()) {
    4706         Ref<WebKit::WebProcessProxy> protectedProcessProxy(provisionalPageProxy->process());
    4707         protectedProcessProxy->requestTermination(WebKit::ProcessTerminationReason::RequestedByClient);
    4708     }
    47094703}
    47104704
  • trunk/Source/WebKit/UIProcess/PageClient.h

    r240010 r240015  
    5050OBJC_CLASS CALayer;
    5151OBJC_CLASS NSFileWrapper;
    52 OBJC_CLASS NSMenu;
    5352OBJC_CLASS NSSet;
    5453OBJC_CLASS WKDrawingView;
  • trunk/Source/WebKit/UIProcess/SuspendedPageProxy.cpp

    r239993 r240015  
    101101    // on the WebProcess side.
    102102    m_process->send(Messages::WebPage::Close(), m_page.pageID());
    103 
    104     if (m_suspensionState == SuspensionState::Suspending)
    105         m_process->removeMessageReceiver(Messages::WebPageProxy::messageReceiverName(), m_page.pageID());
     103    m_process->removeMessageReceiver(Messages::WebPageProxy::messageReceiverName(), m_page.pageID());
    106104
    107105    // We call maybeShutDown() asynchronously since the SuspendedPage is currently being removed from the WebProcessPool
     
    137135
    138136    m_suspensionState = SuspensionState::Resumed;
     137    m_process->removeMessageReceiver(Messages::WebPageProxy::messageReceiverName(), m_page.pageID());
    139138    m_process->send(Messages::WebPage::SetIsSuspended(false), m_page.pageID());
    140139}
     
    152151    m_suspensionToken = nullptr;
    153152#endif
    154 
    155     m_process->removeMessageReceiver(Messages::WebPageProxy::messageReceiverName(), m_page.pageID());
    156153
    157154    if (m_readyToUnsuspendHandler)
  • trunk/Source/WebKit/UIProcess/WebFrameProxy.cpp

    r239993 r240015  
    2828
    2929#include "APINavigation.h"
    30 #include "ProvisionalPageProxy.h"
    3130#include "WebCertificateInfo.h"
    3231#include "WebFramePolicyListenerProxy.h"
     
    7675        return false;
    7776
    78     return this == m_page->mainFrame() || (m_page->provisionalPageProxy() && this == m_page->provisionalPageProxy()->mainFrame());
     77    return this == m_page->mainFrame();
    7978}
    8079
  • trunk/Source/WebKit/UIProcess/WebPageProxy.cpp

    r240010 r240015  
    7878#include "PluginProcessManager.h"
    7979#include "PrintInfo.h"
    80 #include "ProvisionalPageProxy.h"
    8180#include "SafeBrowsingWarning.h"
    8281#include "ShareSheetCallbackID.h"
     
    547546}
    548547
    549 DrawingAreaProxy* WebPageProxy::drawingArea() const
    550 {
    551     if (m_provisionalPage && m_process.ptr() == &m_provisionalPage->process() && m_provisionalPage->drawingArea())
    552         return m_provisionalPage->drawingArea();
    553     return m_drawingArea.get();
    554 }
    555 
    556548void WebPageProxy::changeWebsiteDataStore(WebsiteDataStore& websiteDataStore)
    557549{
     
    777769}
    778770
    779 void WebPageProxy::swapToWebProcess(Ref<WebProcessProxy>&& process, std::unique_ptr<DrawingAreaProxy>&& drawingArea, RefPtr<WebFrameProxy>&& mainFrame)
     771void WebPageProxy::swapToWebProcess(Ref<WebProcessProxy>&& process, std::unique_ptr<SuspendedPageProxy>&& destinationSuspendedPage, IsSwapFromSuspended isSwapFromSuspended)
    780772{
    781773    ASSERT(!m_isClosed);
     
    783775
    784776    m_process = WTFMove(process);
    785     ASSERT(!m_drawingArea);
    786     setDrawingArea(WTFMove(drawingArea));
    787     ASSERT(!m_mainFrame);
    788     m_mainFrame = WTFMove(mainFrame);
    789777    m_isValid = true;
     778
     779    // If we are reattaching to a SuspendedPage, then the WebProcess' WebPage already exists and
     780    // WebPageProxy::didCreateMainFrame() will not be called to initialize m_mainFrame. In such
     781    // case, we need to initialize m_mainFrame to reflect the fact the the WebProcess' WebPage
     782    // already exists and already has a main frame.
     783    if (destinationSuspendedPage) {
     784        if (!destinationSuspendedPage->failedToSuspend()) {
     785            ASSERT(!m_mainFrame);
     786            ASSERT(&destinationSuspendedPage->process() == m_process.ptr());
     787            destinationSuspendedPage->unsuspend();
     788            m_mainFrame = WebFrameProxy::create(*this, destinationSuspendedPage->mainFrameID());
     789            m_process->frameCreated(destinationSuspendedPage->mainFrameID(), *m_mainFrame);
     790        } else {
     791            // We failed to suspend the page so destroy it now and merely reuse its WebContent process.
     792            destinationSuspendedPage = nullptr;
     793        }
     794    }
    790795
    791796    m_process->addExistingWebPage(*this, m_pageID, WebProcessProxy::BeginsUsingDataStore::No);
    792797    m_process->addMessageReceiver(Messages::WebPageProxy::messageReceiverName(), m_pageID, *this);
    793798
    794     // No need to initialize the WebPage since it was created when we created the ProvisionalPageProxy.
    795     finishAttachingToWebProcess(ShouldInitializeWebPage::No);
    796 }
    797 
    798 void WebPageProxy::finishAttachingToWebProcess(ShouldInitializeWebPage shouldInitializePage)
     799    finishAttachingToWebProcess(isSwapFromSuspended);
     800}
     801
     802void WebPageProxy::finishAttachingToWebProcess(IsSwapFromSuspended isSwapFromSuspended)
    799803{
    800804    ASSERT(m_process->state() != ChildProcessProxy::State::Terminated);
     
    832836#endif
    833837
    834     if (shouldInitializePage == ShouldInitializeWebPage::Yes)
    835         initializeWebPage();
     838    initializeWebPage(isSwapFromSuspended);
    836839
    837840    m_inspector->updateForNewPageProcess(this);
     
    898901}
    899902
    900 void WebPageProxy::setDrawingArea(std::unique_ptr<DrawingAreaProxy>&& drawingArea)
    901 {
    902     m_drawingArea = WTFMove(drawingArea);
    903     if (!m_drawingArea)
    904         return;
     903void WebPageProxy::initializeWebPage(IsSwapFromSuspended isSwapFromSuspended)
     904{
     905    ASSERT(isValid());
     906
     907    m_drawingArea = pageClient().createDrawingAreaProxy();
     908    ASSERT(m_drawingArea);
    905909
    906910#if ENABLE(ASYNC_SCROLLING) && PLATFORM(COCOA)
     
    913917    }
    914918#endif
    915 }
    916 
    917 void WebPageProxy::initializeWebPage()
    918 {
    919     ASSERT(isValid());
    920 
    921     setDrawingArea(pageClient().createDrawingAreaProxy());
    922     ASSERT(m_drawingArea);
    923 
    924     process().send(Messages::WebProcess::CreateWebPage(m_pageID, creationParameters()), 0);
     919
     920    auto parameters = creationParameters();
     921    parameters.isSwapFromSuspended = isSwapFromSuspended == IsSwapFromSuspended::Yes;
     922
     923#if ENABLE(SERVICE_WORKER)
     924    parameters.hasRegisteredServiceWorkers = process().processPool().mayHaveRegisteredServiceWorkers(m_websiteDataStore);
     925#endif
     926
     927    process().send(Messages::WebProcess::CreateWebPage(m_pageID, parameters), 0);
    925928
    926929    m_needsToFinishInitializingWebPageAfterProcessLaunch = true;
     
    10741077
    10751078    auto url = request.url();
    1076     if (shouldTreatAsContinuingLoad != ShouldTreatAsContinuingLoad::Yes)
    1077         m_pageLoadState.setPendingAPIRequestURL(transaction, url);
     1079    m_pageLoadState.setPendingAPIRequestURL(transaction, url);
    10781080
    10791081    if (!isValid())
     
    12931295
    12941296    m_process->send(Messages::WebPage::StopLoading(), m_pageID);
    1295     if (m_provisionalPage) {
    1296         m_provisionalPage->cancel();
    1297         m_provisionalPage = nullptr;
    1298     }
    12991297    m_process->responsivenessTimer().start();
    13001298}
     
    27012699
    27022700        if (processForNavigation.ptr() != &process()) {
    2703             policyAction = WebPolicyAction::Ignore;
     2701            policyAction = isPageOpenedByDOMShowingInitialEmptyDocument() ? WebPolicyAction::Ignore : WebPolicyAction::Suspend;
    27042702            RELEASE_LOG_IF_ALLOWED(ProcessSwapping, "decidePolicyForNavigationAction, swapping process %i with process %i for navigation, reason: %{public}s", processIdentifier(), processForNavigation->processIdentifier(), reason.utf8().data());
    27052703            LOG(ProcessSwapping, "(ProcessSwapping) Switching from process %i to new process (%i) for navigation %" PRIu64 " '%s'", processIdentifier(), processForNavigation->processIdentifier(), navigation->navigationID(), navigation->loggingString());
     
    27102708        receivedPolicyDecision(policyAction, navigation.ptr(), shouldProcessSwap ? WTF::nullopt : WTFMove(data), WTFMove(sender));
    27112709
    2712         if (!shouldProcessSwap)
    2713             return;
    2714 
    2715         auto suspendedPage = destinationSuspendedPage ? process().processPool().takeSuspendedPage(*destinationSuspendedPage) : nullptr;
    2716         if (suspendedPage && suspendedPage->failedToSuspend())
    2717             suspendedPage = nullptr;
    2718 
    2719         continueNavigationInNewProcess(navigation, WTFMove(suspendedPage), WTFMove(processForNavigation), processSwapRequestedByClient, WTFMove(data));
     2710        if (shouldProcessSwap)
     2711            continueNavigationInNewProcess(navigation, destinationSuspendedPage ? process().processPool().takeSuspendedPage(*destinationSuspendedPage) : nullptr, WTFMove(processForNavigation), processSwapRequestedByClient, WTFMove(data));
    27202712    });
    27212713}
     
    27532745}
    27542746
    2755 void WebPageProxy::commitProvisionalPage(uint64_t frameID, uint64_t navigationID, const String& mimeType, bool frameHasCustomContentProvider, uint32_t frameLoadType, const WebCore::CertificateInfo& certificateInfo, bool containsPluginDocument, Optional<WebCore::HasInsecureContent> forcedHasInsecureContent, const UserData& userData)
    2756 {
    2757     ASSERT(m_provisionalPage);
    2758     RELEASE_LOG_IF_ALLOWED(Loading, "commitProvisionalPage: previousPID = %i, newPID = %i, pageID = %" PRIu64, m_process->processIdentifier(), m_provisionalPage->process().processIdentifier(), m_pageID);
    2759 
    2760     Optional<uint64_t> mainFrameIDInPreviousProcess = m_mainFrame ? makeOptional(m_mainFrame->frameID()) : WTF::nullopt;
    2761 
    2762     ASSERT(m_process.ptr() != &m_provisionalPage->process());
    2763 
    2764     processDidTerminate(ProcessTerminationReason::NavigationSwap);
    2765 
    2766     m_process->removeMessageReceiver(Messages::WebPageProxy::messageReceiverName(), m_pageID);
    2767     auto* navigation = navigationState().navigation(m_provisionalPage->navigationID());
    2768     bool didSuspendPreviousPage = navigation ? suspendCurrentPageIfPossible(*navigation, mainFrameIDInPreviousProcess, m_provisionalPage->processSwapRequestedByClient()) : false;
    2769     m_process->removeWebPage(*this, m_pageID, WebProcessProxy::EndsUsingDataStore::No);
    2770 
    2771     // There is no way we'll be able to return to the page in the previous page so close it.
    2772     if (!didSuspendPreviousPage)
    2773         m_process->send(Messages::WebPage::Close(), pageID());
    2774 
    2775     swapToWebProcess(m_provisionalPage->process(), m_provisionalPage->takeDrawingArea(), m_provisionalPage->mainFrame());
    2776 
    2777     didCommitLoadForFrame(frameID, navigationID, mimeType, frameHasCustomContentProvider, frameLoadType, certificateInfo, containsPluginDocument, forcedHasInsecureContent, userData);
    2778 
    2779     m_provisionalPage = nullptr;
    2780 }
    2781 
    2782 void WebPageProxy::continueNavigationInNewProcess(API::Navigation& navigation, std::unique_ptr<SuspendedPageProxy>&& suspendedPageProxy, Ref<WebProcessProxy>&& newProcess, ProcessSwapRequestedByClient processSwapRequestedByClient, Optional<WebsitePoliciesData>&& websitePolicies)
     2747void WebPageProxy::continueNavigationInNewProcess(API::Navigation& navigation, std::unique_ptr<SuspendedPageProxy>&& suspendedPageProxy, Ref<WebProcessProxy>&& process, ProcessSwapRequestedByClient processSwapRequestedByClient, Optional<WebsitePoliciesData>&& websitePolicies)
    27832748{
    27842749    RELEASE_LOG_IF_ALLOWED(Loading, "continueNavigationInNewProcess: webPID = %i, pageID = %" PRIu64, m_process->processIdentifier(), m_pageID);
    27852750    LOG(Loading, "Continuing navigation %" PRIu64 " '%s' in a new web process", navigation.navigationID(), navigation.loggingString());
    27862751
    2787     if (m_provisionalPage) {
    2788         if (m_provisionalPage->navigationID() != navigation.navigationID())
    2789             m_provisionalPage->cancel();
    2790         m_provisionalPage = nullptr;
    2791     }
    2792 
    2793     m_provisionalPage = std::make_unique<ProvisionalPageProxy>(*this, newProcess.copyRef(), WTFMove(suspendedPageProxy), navigation.navigationID(), navigation.currentRequestIsRedirect(), navigation.currentRequest(), processSwapRequestedByClient);
     2752    Ref<WebProcessProxy> previousProcess = m_process.copyRef();
     2753    Optional<uint64_t> mainFrameIDInPreviousProcess = m_mainFrame ? makeOptional(m_mainFrame->frameID()) : WTF::nullopt;
     2754    auto mainFrameURL = m_mainFrame ? m_mainFrame->url() : URL();
     2755
     2756    ASSERT(m_process.ptr() != process.ptr());
     2757
     2758    processDidTerminate(ProcessTerminationReason::NavigationSwap);
     2759
     2760    m_process->removeMessageReceiver(Messages::WebPageProxy::messageReceiverName(), m_pageID);
     2761    bool didSuspendPreviousPage = suspendCurrentPageIfPossible(navigation, mainFrameIDInPreviousProcess, processSwapRequestedByClient);
     2762    m_process->removeWebPage(*this, m_pageID, WebProcessProxy::EndsUsingDataStore::No);
     2763
     2764    swapToWebProcess(WTFMove(process), WTFMove(suspendedPageProxy), didSuspendPreviousPage ? IsSwapFromSuspended::Yes : IsSwapFromSuspended::No);
    27942765
    27952766    if (auto* item = navigation.targetItem()) {
     
    27992770        m_pageLoadState.setPendingAPIRequestURL(transaction, item->url());
    28002771
    2801         m_provisionalPage->goToBackForwardItem(navigation, *item, WTFMove(websitePolicies));
     2772        auto itemStates = m_backForwardList->filteredItemStates([this, targetItem = item](WebBackForwardListItem& item) {
     2773            if (auto* page = item.suspendedPage()) {
     2774                if (&page->process() == m_process.ptr())
     2775                    return false;
     2776            }
     2777            return &item != targetItem;
     2778        });
     2779        m_process->send(Messages::WebPage::UpdateBackForwardListForReattach(WTFMove(itemStates)), m_pageID);
     2780        m_process->send(Messages::WebPage::GoToBackForwardItem(navigation.navigationID(), item->itemID(), *navigation.backForwardFrameLoadType(), ShouldTreatAsContinuingLoad::Yes, WTFMove(websitePolicies)), m_pageID);
     2781        m_process->responsivenessTimer().start();
     2782
    28022783        return;
    28032784    }
     
    28062787        // If WebCore is supposed to lock the history for this load, then the new process needs to know about the current history item so it can update
    28072788        // it instead of creating a new one.
    2808         newProcess->send(Messages::WebPage::SetCurrentHistoryItemForReattach(m_backForwardList->currentItem()->itemState()), m_pageID);
     2789        m_process->send(Messages::WebPage::SetCurrentHistoryItemForReattach(m_backForwardList->currentItem()->itemState()), m_pageID);
    28092790    }
    28102791
     
    28122793    ASSERT(!navigation.currentRequest().isEmpty());
    28132794    if (auto& substituteData = navigation.substituteData())
    2814         m_provisionalPage->loadDataWithNavigation(navigation, { substituteData->content.data(), substituteData->content.size() }, substituteData->MIMEType, substituteData->encoding, substituteData->baseURL, substituteData->userData.get(), WTFMove(websitePolicies));
     2795        loadDataWithNavigation(navigation, { substituteData->content.data(), substituteData->content.size() }, substituteData->MIMEType, substituteData->encoding, substituteData->baseURL, substituteData->userData.get(), ShouldTreatAsContinuingLoad::Yes, WTFMove(websitePolicies));
    28152796    else
    2816         m_provisionalPage->loadRequestWithNavigation(navigation, ResourceRequest { navigation.currentRequest() }, WebCore::ShouldOpenExternalURLsPolicy::ShouldAllowExternalSchemes, nullptr, WTFMove(websitePolicies));
     2797        loadRequestWithNavigation(navigation, ResourceRequest { navigation.currentRequest() }, WebCore::ShouldOpenExternalURLsPolicy::ShouldAllowExternalSchemes, nullptr, ShouldTreatAsContinuingLoad::Yes, WTFMove(websitePolicies));
     2798
     2799    ASSERT(!m_mainFrame);
     2800    m_mainFrameCreationHandler = [this, weakThis = makeWeakPtr(*this), navigationID = navigation.navigationID(), request =  navigation.currentRequest(), mainFrameURL, isServerRedirect = navigation.currentRequestIsRedirect()]() mutable {
     2801        if (!weakThis)
     2802            return;
     2803
     2804        ASSERT(m_mainFrame);
     2805        // This navigation was destroyed so no need to notify of redirect.
     2806        if (!navigationState().navigation(navigationID))
     2807            return;
     2808
     2809        // Restore the main frame's committed URL as some clients may rely on it until the next load is committed.
     2810        m_mainFrame->frameLoadState().setURL(mainFrameURL);
     2811
     2812        // Normally, notification of a server redirect comes from the WebContent process.
     2813        // If we are process swapping in response to a server redirect then that notification will not come from the new WebContent process.
     2814        // In this case we have the UIProcess synthesize the redirect notification at the appropriate time.
     2815        if (isServerRedirect) {
     2816            m_mainFrame->frameLoadState().didStartProvisionalLoad(request.url());
     2817            didReceiveServerRedirectForProvisionalLoadForFrame(m_mainFrame->frameID(), navigationID, WTFMove(request), { });
     2818        }
     2819    };
     2820
     2821    if (!m_process->processPool().configuration().processSwapsOnWindowOpenWithOpener() || !isPageOpenedByDOMShowingInitialEmptyDocument() || !mainFrameIDInPreviousProcess) {
     2822        // There is no way we'll be able to return to the page in the previous page so close it.
     2823        if (!didSuspendPreviousPage)
     2824            previousProcess->send(Messages::WebPage::Close(), m_pageID);
     2825        return;
     2826    }
     2827
     2828    m_mainFrameWindowCreationHandler = [this, previousProcess = WTFMove(previousProcess), mainFrameIDInPreviousProcess = *mainFrameIDInPreviousProcess](const GlobalWindowIdentifier& windowIdentifier) {
     2829        ASSERT(m_mainFrame);
     2830        GlobalFrameIdentifier navigatedFrameIdentifierInNewProcess { pageID(), m_mainFrame->frameID() };
     2831        previousProcess->send(Messages::WebPage::FrameBecameRemote(mainFrameIDInPreviousProcess, navigatedFrameIdentifierInNewProcess, windowIdentifier), pageID());
     2832    };
    28172833}
    28182834
     
    36793695    // Add the frame to the process wide map.
    36803696    m_process->frameCreated(frameID, *m_mainFrame);
     3697
     3698    if (m_mainFrameCreationHandler) {
     3699        m_mainFrameCreationHandler();
     3700        m_mainFrameCreationHandler = nullptr;
     3701    }
    36813702}
    36823703
     
    37033724void WebPageProxy::didCreateWindow(uint64_t frameID, GlobalWindowIdentifier&& windowIdentifier)
    37043725{
     3726    if (m_mainFrame && m_mainFrame->frameID() == frameID) {
     3727        if (auto mainFrameWindowCreationHandler = WTFMove(m_mainFrameWindowCreationHandler))
     3728            mainFrameWindowCreationHandler(windowIdentifier);
     3729    }
    37053730}
    37063731
     
    37543779{
    37553780    PageClientProtector protector(pageClient());
    3756 
    3757     // On process-swap, the previous process tries to destroy the navigation but the provisional process is actually taking over the navigation.
    3758     if (m_provisionalPage && m_provisionalPage->navigationID() == navigationID)
    3759         return;
    37603781
    37613782    // FIXME: Message check the navigationID.
     
    37753796    if (frame->isMainFrame() && navigationID)
    37763797        navigation = navigationState().navigation(navigationID);
     3798
     3799    // If this seemingly new load is actually continuing a server redirect for a previous navigation in a new process,
     3800    // then we ignore this notification.
     3801    if (navigation && navigation->currentRequestIsRedirect()) {
     3802        auto navigationProcessIdentifier = navigation->currentRequestProcessIdentifier();
     3803        if (navigationProcessIdentifier && *navigationProcessIdentifier != m_process->coreProcessIdentifier())
     3804            return;
     3805    }
    37773806
    37783807    LOG(Loading, "WebPageProxy %" PRIu64 " in process pid %i didStartProvisionalLoadForFrame to frameID %" PRIu64 ", navigationID %" PRIu64 ", url %s", m_pageID, m_process->processIdentifier(), frameID, navigationID, url.string().utf8().data());
     
    38823911
    38833912    PageClientProtector protector(pageClient());
    3884 
    3885     if (m_provisionalPage && m_provisionalPage->navigationID() == navigationID && &m_provisionalPage->process() != m_process.ptr()) {
    3886         // The load did not fail, it is merely happening in a new provisional process.
    3887         return;
    3888     }
    38893913
    38903914    WebFrameProxy* frame = m_process->webFrame(frameID);
     
    39263950
    39273951    m_failingProvisionalLoadURL = { };
    3928 
    3929     // If the provisional page's load fails then we destroy the provisional page.
    3930     if (m_provisionalPage && m_provisionalPage->mainFrame() == frame)
    3931         m_provisionalPage = nullptr;
    39323952}
    39333953
     
    43214341    MESSAGE_CHECK(frame);
    43224342
    4323     decidePolicyForNavigationAction(*frame, WTFMove(frameSecurityOrigin), navigationID, WTFMove(navigationActionData), WTFMove(frameInfoData), originatingPageID, originalRequest, WTFMove(request), WTFMove(requestBody), WTFMove(redirectResponse), userData, PolicyDecisionSender::create([this, protectedThis = makeRef(*this), frameID, listenerID, process = m_process.copyRef()] (auto... args) {
    4324         process->send(Messages::WebPage::DidReceivePolicyDecision(frameID, listenerID, args...), m_pageID);
     4343    decidePolicyForNavigationAction(*frame, WTFMove(frameSecurityOrigin), navigationID, WTFMove(navigationActionData), WTFMove(frameInfoData), originatingPageID, originalRequest, WTFMove(request), WTFMove(requestBody), WTFMove(redirectResponse), userData, PolicyDecisionSender::create([this, protectedThis = makeRef(*this), frameID, listenerID] (auto... args) {
     4344        m_process->send(Messages::WebPage::DidReceivePolicyDecision(frameID, listenerID, args...), m_pageID);
    43254345    }));
    43264346}
     
    45564576
    45574577    RefPtr<API::Navigation> navigation = navigationID ? m_navigationState->navigation(navigationID) : nullptr;
    4558     auto listener = makeRef(frame->setUpPolicyListenerProxy([this, protectedThis = makeRef(*this), frameID, listenerID, navigation = WTFMove(navigation), process = m_process.copyRef()] (WebPolicyAction policyAction, API::WebsitePolicies*, ProcessSwapRequestedByClient processSwapRequestedByClient, RefPtr<SafeBrowsingWarning>&& safeBrowsingWarning) mutable {
     4578    auto listener = makeRef(frame->setUpPolicyListenerProxy([this, protectedThis = makeRef(*this), frameID, listenerID, navigation = WTFMove(navigation)] (WebPolicyAction policyAction, API::WebsitePolicies*, ProcessSwapRequestedByClient processSwapRequestedByClient, RefPtr<SafeBrowsingWarning>&& safeBrowsingWarning) mutable {
    45594579        // FIXME: Assert the API::WebsitePolicies* is nullptr here once clients of WKFramePolicyListenerUseWithPolicies go away.
    45604580        RELEASE_ASSERT(processSwapRequestedByClient == ProcessSwapRequestedByClient::No);
    45614581        ASSERT_UNUSED(safeBrowsingWarning, !safeBrowsingWarning);
    4562         receivedPolicyDecision(policyAction, navigation.get(), WTF::nullopt, PolicyDecisionSender::create([this, protectedThis = WTFMove(protectedThis), frameID, listenerID, process = WTFMove(process)] (auto... args) {
    4563             process->send(Messages::WebPage::DidReceivePolicyDecision(frameID, listenerID, args...), m_pageID);
     4582        receivedPolicyDecision(policyAction, navigation.get(), WTF::nullopt, PolicyDecisionSender::create([this, protectedThis = WTFMove(protectedThis), frameID, listenerID] (auto... args) {
     4583            m_process->send(Messages::WebPage::DidReceivePolicyDecision(frameID, listenerID, args...), m_pageID);
    45644584        }));
    45654585    }, ShouldExpectSafeBrowsingResult::No));
     
    63846404}
    63856405
    6386 void WebPageProxy::provisionalProcessDidTerminate()
    6387 {
    6388     ASSERT(m_provisionalPage);
    6389     m_provisionalPage->cancel();
    6390     m_provisionalPage = nullptr;
    6391 }
    6392 
    63936406static bool shouldReloadAfterProcessTermination(ProcessTerminationReason reason)
    63946407{
     
    64786491{
    64796492    m_mainFrame = nullptr;
     6493    m_mainFrameCreationHandler = nullptr;
     6494    m_mainFrameWindowCreationHandler = nullptr;
    64806495
    64816496#if PLATFORM(COCOA)
     
    67686783#endif
    67696784
    6770 #if ENABLE(SERVICE_WORKER)
    6771     parameters.hasRegisteredServiceWorkers = process().processPool().mayHaveRegisteredServiceWorkers(m_websiteDataStore);
    6772 #endif
    6773 
    67746785    parameters.needsFontAttributes = m_needsFontAttributes;
    67756786
     
    85338544}
    85348545
    8535 WebPageProxy::PageProcessOverride::PageProcessOverride(WebPageProxy& page, WebProcessProxy& newProcess)
    8536     : m_page(&page)
    8537     , m_previousProcess(page.process())
    8538 {
    8539     page.m_process = newProcess;
    8540 }
    8541 
    8542 WebPageProxy::PageProcessOverride::PageProcessOverride(PageProcessOverride&&) = default;
    8543 
    8544 WebPageProxy::PageProcessOverride::~PageProcessOverride()
    8545 {
    8546     if (m_page)
    8547         m_page->m_process = WTFMove(m_previousProcess);
    8548 }
    8549 
    85508546#if ENABLE(DATA_DETECTION)
    85518547
  • trunk/Source/WebKit/UIProcess/WebPageProxy.h

    r239993 r240015  
    226226class NativeWebWheelEvent;
    227227class PageClient;
    228 class ProvisionalPageProxy;
    229228class RemoteLayerTreeHost;
    230229class RemoteLayerTreeScrollingPerformanceData;
     
    358357    WebFrameProxy* frameSetLargestFrame() const { return m_frameSetLargestFrame.get(); }
    359358
    360     DrawingAreaProxy* drawingArea() const;
     359    DrawingAreaProxy* drawingArea() const { return m_drawingArea.get(); }
    361360
    362361    WebNavigationState& navigationState() { return *m_navigationState.get(); }
     
    381380    bool addsVisitedLinks() const { return m_addsVisitedLinks; }
    382381    void setAddsVisitedLinks(bool addsVisitedLinks) { m_addsVisitedLinks = addsVisitedLinks; }
    383     VisitedLinkStore& visitedLinkStore() { return m_visitedLinkStore; }
    384382
    385383    void exitFullscreenImmediately();
     
    461459    void setIconLoadingClient(std::unique_ptr<API::IconLoadingClient>&&);
    462460
    463     void initializeWebPage();
    464     void setDrawingArea(std::unique_ptr<DrawingAreaProxy>&&);
     461    enum class IsSwapFromSuspended { No, Yes };
     462    void initializeWebPage(IsSwapFromSuspended = IsSwapFromSuspended::No);
    465463
    466464    WeakPtr<SecKeyProxyStore> secKeyProxyStore(const WebCore::AuthenticationChallenge&);
     
    1000998    void processDidBecomeResponsive();
    1001999    void processDidTerminate(ProcessTerminationReason);
    1002     void provisionalProcessDidTerminate();
    10031000    void dispatchProcessDidTerminate(ProcessTerminationReason);
    10041001    void willChangeProcessIsResponsive();
     
    10281025    WebProcessProxy& process() { return m_process; }
    10291026    ProcessID processIdentifier() const;
    1030 
    1031     class PageProcessOverride {
    1032     public:
    1033         PageProcessOverride(WebPageProxy&, WebProcessProxy& newProcess);
    1034         PageProcessOverride(PageProcessOverride&&);
    1035         ~PageProcessOverride();
    1036 
    1037     private:
    1038         RefPtr<WebPageProxy> m_page;
    1039         Ref<WebProcessProxy> m_previousProcess;
    1040     };
    1041 
    1042     PageProcessOverride temporarilyOverrideProcess(WebProcessProxy& newProcess) { return PageProcessOverride(*this, newProcess); }
    10431027
    10441028    WebPreferences& preferences() { return m_preferences; }
     
    14321416#endif
    14331417
    1434     ProvisionalPageProxy* provisionalPageProxy() const { return m_provisionalPage.get(); }
    1435     void commitProvisionalPage(uint64_t frameID, uint64_t navigationID, const String& mimeType, bool frameHasCustomContentProvider, uint32_t frameLoadType, const WebCore::CertificateInfo&, bool containsPluginDocument, Optional<WebCore::HasInsecureContent> forcedHasInsecureContent, const UserData&);
    1436 
    1437     void didStartProvisionalLoadForFrame(uint64_t frameID, uint64_t navigationID, URL&&, URL&& unreachableURL, const UserData&);
    1438     void didFailProvisionalLoadForFrame(uint64_t frameID, const WebCore::SecurityOriginData& frameSecurityOrigin, uint64_t navigationID, const String& provisionalURL, const WebCore::ResourceError&, const UserData&);
    1439     void didReceiveServerRedirectForProvisionalLoadForFrame(uint64_t frameID, uint64_t navigationID, WebCore::ResourceRequest&&, const UserData&);
    1440 
    1441     void loadDataWithNavigation(API::Navigation&, const IPC::DataReference&, const String& MIMEType, const String& encoding, const String& baseURL, API::Object* userData, WebCore::ShouldTreatAsContinuingLoad, Optional<WebsitePoliciesData>&& = WTF::nullopt);
    1442     void loadRequestWithNavigation(API::Navigation&, WebCore::ResourceRequest&&, WebCore::ShouldOpenExternalURLsPolicy, API::Object* userData, WebCore::ShouldTreatAsContinuingLoad, Optional<WebsitePoliciesData>&& = WTF::nullopt);
    1443 
    1444     // IPC::MessageReceiver
    1445     // Implemented in generated WebPageProxyMessageReceiver.cpp
    1446     void didReceiveMessage(IPC::Connection&, IPC::Decoder&) override;
    1447     void didReceiveSyncMessage(IPC::Connection&, IPC::Decoder&, std::unique_ptr<IPC::Encoder>&) override;
    1448 
    14491418private:
    14501419    WebPageProxy(PageClient&, WebProcessProxy&, uint64_t pageID, Ref<API::PageConfiguration>&&);
     
    14711440    void setUserAgent(String&&);
    14721441
     1442    // IPC::MessageReceiver
     1443    // Implemented in generated WebPageProxyMessageReceiver.cpp
     1444    void didReceiveMessage(IPC::Connection&, IPC::Decoder&) override;
     1445    void didReceiveSyncMessage(IPC::Connection&, IPC::Decoder&, std::unique_ptr<IPC::Encoder>&) override;
     1446
     1447
    14731448    // IPC::MessageSender
    14741449    bool sendMessage(std::unique_ptr<IPC::Encoder>, OptionSet<IPC::SendOption>) override;
     
    14921467    void didCreateWindow(uint64_t frameID, WebCore::GlobalWindowIdentifier&&);
    14931468
     1469    void didStartProvisionalLoadForFrame(uint64_t frameID, uint64_t navigationID, URL&&, URL&& unreachableURL, const UserData&);
     1470    void didReceiveServerRedirectForProvisionalLoadForFrame(uint64_t frameID, uint64_t navigationID, WebCore::ResourceRequest&&, const UserData&);
    14941471    void willPerformClientRedirectForFrame(uint64_t frameID, const String& url, double delay, WebCore::LockBackForwardList);
    14951472    void didCancelClientRedirectForFrame(uint64_t frameID);
    14961473    void didChangeProvisionalURLForFrame(uint64_t frameID, uint64_t navigationID, URL&&);
     1474    void didFailProvisionalLoadForFrame(uint64_t frameID, const WebCore::SecurityOriginData& frameSecurityOrigin, uint64_t navigationID, const String& provisionalURL, const WebCore::ResourceError&, const UserData&);
    14971475    void didCommitLoadForFrame(uint64_t frameID, uint64_t navigationID, const String& mimeType, bool frameHasCustomContentProvider, uint32_t frameLoadType, const WebCore::CertificateInfo&, bool containsPluginDocument, Optional<WebCore::HasInsecureContent> forcedHasInsecureContent, const UserData&);
    14981476    void didFinishDocumentLoadForFrame(uint64_t frameID, uint64_t navigationID, const UserData&);
     
    15981576
    15991577    void reattachToWebProcess();
    1600     void swapToWebProcess(Ref<WebProcessProxy>&&, std::unique_ptr<DrawingAreaProxy>&&, RefPtr<WebFrameProxy>&& mainFrame);
     1578    void swapToWebProcess(Ref<WebProcessProxy>&&, std::unique_ptr<SuspendedPageProxy>&&, IsSwapFromSuspended);
    16011579    void didFailToSuspendAfterProcessSwap();
    16021580    void didSuspendAfterProcessSwap();
    16031581
    1604     enum class ShouldInitializeWebPage { No, Yes };
    1605     void finishAttachingToWebProcess(ShouldInitializeWebPage = ShouldInitializeWebPage::Yes);
     1582    void finishAttachingToWebProcess(IsSwapFromSuspended = IsSwapFromSuspended::No);
    16061583
    16071584    RefPtr<API::Navigation> reattachToWebProcessForReload();
    16081585    RefPtr<API::Navigation> reattachToWebProcessWithItem(WebBackForwardListItem&);
     1586
     1587    void loadDataWithNavigation(API::Navigation&, const IPC::DataReference&, const String& MIMEType, const String& encoding, const String& baseURL, API::Object* userData, WebCore::ShouldTreatAsContinuingLoad, Optional<WebsitePoliciesData>&& = WTF::nullopt);
     1588    void loadRequestWithNavigation(API::Navigation&, WebCore::ResourceRequest&&, WebCore::ShouldOpenExternalURLsPolicy, API::Object* userData, WebCore::ShouldTreatAsContinuingLoad, Optional<WebsitePoliciesData>&& = WTF::nullopt);
    16091589
    16101590    void requestNotificationPermission(uint64_t notificationID, const String& originString);
     
    19731953
    19741954    RefPtr<WebFrameProxy> m_mainFrame;
     1955    Function<void()> m_mainFrameCreationHandler;
     1956    Function<void(const WebCore::GlobalWindowIdentifier&)> m_mainFrameWindowCreationHandler;
    19751957
    19761958    RefPtr<WebFrameProxy> m_focusedFrame;
     
    23432325    bool m_mayHaveUniversalFileReadSandboxExtension { false };
    23442326
    2345     std::unique_ptr<ProvisionalPageProxy> m_provisionalPage;
    2346 
    23472327#if HAVE(PENCILKIT)
    23482328    std::unique_ptr<EditableImageController> m_editableImageController;
  • trunk/Source/WebKit/UIProcess/WebProcessProxy.cpp

    r239993 r240015  
    3535#include "PluginInfoStore.h"
    3636#include "PluginProcessManager.h"
    37 #include "ProvisionalPageProxy.h"
    3837#include "TextChecker.h"
    3938#include "TextCheckerState.h"
     
    586585#endif
    587586
    588 bool WebProcessProxy::hasProvisionalPageWithID(uint64_t pageID) const
    589 {
    590     for (auto* provisionalPage : m_provisionalPages) {
    591         if (provisionalPage->page().pageID() == pageID)
    592             return true;
    593     }
    594     return false;
    595 }
    596 
    597587void WebProcessProxy::updateBackForwardItem(const BackForwardListItemState& itemState)
    598588{
     
    602592        // e.g. The old web process is navigating to about:blank for suspension.
    603593        // We ignore these updates.
    604         if (m_pageMap.contains(item->pageID()) || hasProvisionalPageWithID(item->pageID()))
     594        if (m_pageMap.contains(item->pageID()))
    605595            item->setPageState(itemState.pageState);
    606596    }
     
    705695
    706696    auto pages = copyToVectorOf<RefPtr<WebPageProxy>>(m_pageMap.values());
    707     auto provisionalPages = WTF::map(m_provisionalPages, [](auto* provisionalPage) { return makeWeakPtr(provisionalPage); });
    708697
    709698    shutDown();
     
    720709    for (auto& page : pages)
    721710        page->processDidTerminate(ProcessTerminationReason::Crash);
    722 
    723     for (auto& provisionalPage : provisionalPages) {
    724         if (provisionalPage)
    725             provisionalPage->processDidTerminate();
    726     }
    727711}
    728712
     
    796780        page->processDidFinishLaunching();
    797781    }
    798 
    799     for (auto* provisionalPage : m_provisionalPages) {
    800         ASSERT(this == &provisionalPage->process());
    801         provisionalPage->processDidFinishLaunching();
    802     }
    803 
    804782
    805783    RELEASE_ASSERT(!m_webConnection);
     
    896874bool WebProcessProxy::canTerminateChildProcess()
    897875{
    898     if (!m_pageMap.isEmpty() || m_processPool->hasSuspendedPageFor(*this) || !m_provisionalPages.isEmpty())
     876    if (!m_pageMap.isEmpty() || m_processPool->hasSuspendedPageFor(*this))
    899877        return false;
    900878
  • trunk/Source/WebKit/UIProcess/WebProcessProxy.h

    r239993 r240015  
    7171class ObjCObjectGraph;
    7272class PageClient;
    73 class ProvisionalPageProxy;
    7473class UserMediaCaptureManagerProxy;
    7574class VisitedLinkStore;
     
    126125    void removeWebPage(WebPageProxy&, uint64_t pageID, EndsUsingDataStore);
    127126
    128     void addProvisionalPageProxy(ProvisionalPageProxy& provisionalPage) { ASSERT(!m_provisionalPages.contains(&provisionalPage)); m_provisionalPages.add(&provisionalPage); }
    129     void removeProvisionalPageProxy(ProvisionalPageProxy& provisionalPage) { ASSERT(m_provisionalPages.contains(&provisionalPage)); m_provisionalPages.remove(&provisionalPage); }
    130 
    131127    typename WebPageProxyMap::ValuesConstIteratorRange pages() const { return m_pageMap.values(); }
    132128    unsigned pageCount() const { return m_pageMap.size(); }
     
    335331    void logDiagnosticMessageForResourceLimitTermination(const String& limitKey);
    336332
    337     bool hasProvisionalPageWithID(uint64_t pageID) const;
    338 
    339333    enum class IsWeak { No, Yes };
    340334    template<typename T> class WeakOrStrongPtr {
     
    380374    WebPageProxyMap m_pageMap;
    381375    WebFrameProxyMap m_frameMap;
    382     HashSet<ProvisionalPageProxy*> m_provisionalPages;
    383376    UserInitiatedActionMap m_userInitiatedActionMap;
    384377
  • trunk/Source/WebKit/WebKit.xcodeproj/project.pbxproj

    r240014 r240015  
    30723072                466BC0391FA266C9002FA9C1 /* WebSWContextManagerConnection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebSWContextManagerConnection.h; sourceTree = "<group>"; };
    30733073                466BC03A1FA266C9002FA9C1 /* WebSWContextManagerConnection.messages.in */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = WebSWContextManagerConnection.messages.in; sourceTree = "<group>"; };
    3074                 4683569A21E81CC7006E27A3 /* ProvisionalPageProxy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ProvisionalPageProxy.h; sourceTree = "<group>"; };
    3075                 4683569B21E81CC7006E27A3 /* ProvisionalPageProxy.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ProvisionalPageProxy.cpp; sourceTree = "<group>"; };
    30763074                46A2B6061E5675A200C3DEDA /* BackgroundProcessResponsivenessTimer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = BackgroundProcessResponsivenessTimer.cpp; sourceTree = "<group>"; };
    30773075                46A2B6071E5675A200C3DEDA /* BackgroundProcessResponsivenessTimer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = BackgroundProcessResponsivenessTimer.h; sourceTree = "<group>"; };
     
    73207318                                86E67A21190F411800004AB7 /* ProcessThrottler.h */,
    73217319                                83048AE51ACA45DC0082C832 /* ProcessThrottlerClient.h */,
    7322                                 4683569B21E81CC7006E27A3 /* ProvisionalPageProxy.cpp */,
    7323                                 4683569A21E81CC7006E27A3 /* ProvisionalPageProxy.h */,
    73247320                                A55BA81B1BA25B1E007CD33D /* RemoteWebInspectorProxy.cpp */,
    73257321                                A55BA8191BA25B1E007CD33D /* RemoteWebInspectorProxy.h */,
  • trunk/Source/WebKit/WebProcess/WebPage/WebFrame.cpp

    r239993 r240015  
    264264    case WebPolicyAction::Download:
    265265        return WebCore::PolicyAction::Download;
     266    case WebPolicyAction::Suspend:
     267        break;
    266268    }
    267269    ASSERT_NOT_REACHED();
     
    271273void WebFrame::didReceivePolicyDecision(uint64_t listenerID, WebPolicyAction action, uint64_t navigationID, DownloadID downloadID, Optional<WebsitePoliciesData>&& websitePolicies)
    272274{
    273     if (!m_coreFrame || !m_policyListenerID || listenerID != m_policyListenerID || !m_policyFunction)
     275    if (!m_coreFrame || !m_policyListenerID || listenerID != m_policyListenerID || !m_policyFunction) {
     276        if (action == WebPolicyAction::Suspend)
     277            page()->send(Messages::WebPageProxy::DidFailToSuspendAfterProcessSwap());
    274278        return;
     279    }
    275280
    276281    FramePolicyFunction function = WTFMove(m_policyFunction);
     
    288293    }
    289294
     295    bool shouldSuspend = false;
     296    if (action == WebPolicyAction::Suspend) {
     297        shouldSuspend = true;
     298        action = WebPolicyAction::Ignore;
     299    }
     300
    290301    function(toPolicyAction(action));
     302
     303    if (shouldSuspend)
     304        page()->suspendForProcessSwap();
    291305}
    292306
  • trunk/Source/WebKit/WebProcess/WebPage/WebPage.cpp

    r240014 r240015  
    403403    , m_cpuLimit(parameters.cpuLimit)
    404404#if PLATFORM(MAC)
    405     , m_shouldAttachDrawingAreaOnPageTransition(parameters.isProcessSwap)
     405    , m_shouldAttachDrawingAreaOnPageTransition(parameters.isSwapFromSuspended)
    406406#endif
    407407{
     
    474474    m_drawingArea->setShouldScaleViewToFitDocument(parameters.shouldScaleViewToFitDocument);
    475475
    476     if (parameters.isProcessSwap)
    477         freezeLayerTree(LayerTreeFreezeReason::ProcessSwap);
     476    if (parameters.isSwapFromSuspended)
     477        freezeLayerTree(LayerTreeFreezeReason::SwapFromSuspended);
    478478
    479479#if ENABLE(ASYNC_SCROLLING)
     
    699699        m_drawingArea->setPaintingEnabled(true);
    700700#if PLATFORM(MAC)
    701         m_shouldAttachDrawingAreaOnPageTransition = parameters.isProcessSwap;
     701        m_shouldAttachDrawingAreaOnPageTransition = parameters.isSwapFromSuspended;
    702702#endif
    703703        unfreezeLayerTree(LayerTreeFreezeReason::PageSuspended);
     
    30563056    if (!frame)
    30573057        return;
     3058    if (policyAction == WebPolicyAction::Suspend) {
     3059        ASSERT(frame == m_mainFrame);
     3060        setIsSuspended(true);
     3061
     3062        WebProcess::singleton().sendPrewarmInformation(mainWebFrame()->url());
     3063    }
    30583064    frame->didReceivePolicyDecision(listenerID, policyAction, navigationID, downloadID, WTFMove(websitePolicies));
    30593065}
     
    30973103    bool isInitialEmptyDocument = !m_mainFrame;
    30983104    if (!isInitialEmptyDocument)
    3099         unfreezeLayerTree(LayerTreeFreezeReason::ProcessSwap);
     3105        unfreezeLayerTree(LayerTreeFreezeReason::SwapFromSuspended);
    31003106
    31013107#if PLATFORM(MAC)
     
    63096315        // Unfrozen on drawing area reset.
    63106316        freezeLayerTree(LayerTreeFreezeReason::PageSuspended);
    6311 
    6312         WebProcess::singleton().sendPrewarmInformation(mainWebFrame()->url());
    6313 
    6314         suspendForProcessSwap();
    63156317    } else
    63166318        m_shouldResetDrawingAreaAfterSuspend = true;
  • trunk/Source/WebKit/WebProcess/WebPage/WebPage.h

    r239993 r240015  
    697697        PageSuspended           = 1 << 3,
    698698        Printing                = 1 << 4,
    699         ProcessSwap             = 1 << 5,
     699        SwapFromSuspended       = 1 << 5,
    700700    };
    701701    void freezeLayerTree(LayerTreeFreezeReason);
  • trunk/Source/WebKit/WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.mm

    r239993 r240015  
    9898    setColorSpace(parameters.colorSpace);
    9999
    100     if (!parameters.isProcessSwap)
     100    if (!parameters.isSwapFromSuspended)
    101101        attach();
    102102}
  • trunk/Tools/ChangeLog

    r240010 r240015  
     12019-01-15  Chris Dumez  <cdumez@apple.com>
     2
     3        Unreviewed, rolling out r239993, r239995, r239997, and
     4        r239999.
     5
     6        Caused assertions under
     7        ViewGestureController::disconnectFromProcess()
     8
     9        Reverted changesets:
     10
     11        "Regression(PSON) View becomes blank after click a cross-site
     12        download link"
     13        https://bugs.webkit.org/show_bug.cgi?id=193361
     14        https://trac.webkit.org/changeset/239993
     15
     16        "Unreviewed iOS build fix after r239993."
     17        https://trac.webkit.org/changeset/239995
     18
     19        "Fix iOS build after r239993"
     20        https://bugs.webkit.org/show_bug.cgi?id=193361
     21        https://trac.webkit.org/changeset/239997
     22
     23        "Unreviewed, revert part of r239997 as it is not needed to fix
     24        the build."
     25        https://trac.webkit.org/changeset/239999
     26
    1272019-01-15  Tim Horton  <timothy_horton@apple.com>
    228
  • trunk/Tools/TestWebKitAPI/Tests/WebKitCocoa/ProcessSwapOnNavigation.mm

    r239993 r240015  
    11/*
    2  * Copyright (C) 2017-2019 Apple Inc. All rights reserved.
     2 * Copyright (C) 2017 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
     
    7373static bool willPerformClientRedirect;
    7474static bool didPerformClientRedirect;
    75 static bool shouldConvertToDownload;
    7675static RetainPtr<NSURL> clientRedirectSourceURL;
    7776static RetainPtr<NSURL> clientRedirectDestinationURL;
     
    128127        decisionHandler(WKNavigationActionPolicyAllow);
    129128    didRepondToPolicyDecisionCall = true;
    130 }
    131 
    132 - (void)webView:(WKWebView *)webView decidePolicyForNavigationResponse:(WKNavigationResponse *)navigationResponse decisionHandler:(void (^)(WKNavigationResponsePolicy))decisionHandler
    133 {
    134     decisionHandler(shouldConvertToDownload ? _WKNavigationResponsePolicyBecomeDownload : WKNavigationResponsePolicyAllow);
    135129}
    136130
     
    14121406    EXPECT_FALSE(serverRedirected);
    14131407    EXPECT_EQ(3, numberOfDecidePolicyCalls);
    1414     EXPECT_EQ(3u, seenPIDs.size());
     1408    EXPECT_EQ(2u, seenPIDs.size());
    14151409}
    14161410
     
    14721466
    14731467    EXPECT_WK_STREQ(@"pson://www.webkit.org/main1.html", [[webView URL] absoluteString]);
    1474 }
    1475 
    1476 static const char* linkToWebKitBytes = R"PSONRESOURCE(
    1477 <body>
    1478   <a id="testLink" href="pson://www.webkit.org/main.html">Link</a>
    1479 </body>
    1480 )PSONRESOURCE";
    1481 
    1482 TEST(ProcessSwap, PolicyCancelAfterServerRedirect)
    1483 {
    1484     auto processPoolConfiguration = adoptNS([[_WKProcessPoolConfiguration alloc] init]);
    1485     processPoolConfiguration.get().processSwapsOnNavigation = YES;
    1486     auto processPool = adoptNS([[WKProcessPool alloc] _initWithConfiguration:processPoolConfiguration.get()]);
    1487 
    1488     auto webViewConfiguration = adoptNS([[WKWebViewConfiguration alloc] init]);
    1489     [webViewConfiguration setProcessPool:processPool.get()];
    1490     auto handler = adoptNS([[PSONScheme alloc] init]);
    1491     [handler addMappingFromURLString:@"pson://www.google.com/main.html" toData:linkToWebKitBytes];
    1492     [handler addRedirectFromURLString:@"pson://www.webkit.org/main.html" toURLString:@"pson://www.apple.com/ignore.html"];
    1493     [webViewConfiguration setURLSchemeHandler:handler.get() forURLScheme:@"pson"];
    1494 
    1495     auto webView = adoptNS([[WKWebView alloc] initWithFrame:NSMakeRect(0, 0, 800, 600) configuration:webViewConfiguration.get()]);
    1496     auto navigationDelegate = adoptNS([[PSONNavigationDelegate alloc] init]);
    1497     [webView setNavigationDelegate:navigationDelegate.get()];
    1498 
    1499     navigationDelegate->decidePolicyForNavigationAction = ^(WKNavigationAction *action, void (^decisionHandler)(WKNavigationActionPolicy)) {
    1500         if ([action.request.URL.absoluteString hasSuffix:@"ignore.html"]) {
    1501             decisionHandler(WKNavigationActionPolicyCancel);
    1502             return;
    1503         }
    1504         decisionHandler(WKNavigationActionPolicyAllow);
    1505     };
    1506 
    1507     NSURLRequest *request = [NSURLRequest requestWithURL:[NSURL URLWithString:@"pson://www.google.com/main.html"]];
    1508     [webView loadRequest:request];
    1509 
    1510     TestWebKitAPI::Util::run(&done);
    1511     done = false;
    1512     auto pidAfterFirstLoad = [webView _webProcessIdentifier];
    1513 
    1514     EXPECT_EQ(1, numberOfDecidePolicyCalls);
    1515 
    1516     [webView evaluateJavaScript:@"testLink.click()" completionHandler:nil];
    1517 
    1518     TestWebKitAPI::Util::run(&failed);
    1519     failed = false;
    1520     done = false;
    1521 
    1522     EXPECT_EQ(3, numberOfDecidePolicyCalls);
    1523 
    1524     // We should still be on google.com.
    1525     EXPECT_EQ(pidAfterFirstLoad, [webView _webProcessIdentifier]);
    1526     EXPECT_WK_STREQ(@"pson://www.google.com/main.html", [[webView URL] absoluteString]);
    1527 
    1528     [webView evaluateJavaScript:@"testLink.innerText" completionHandler: [&] (id innerText, NSError *error) {
    1529         EXPECT_WK_STREQ(@"Link", innerText);
    1530         done = true;
    1531     }];
    1532     TestWebKitAPI::Util::run(&done);
    1533     done = false;
    1534 }
    1535 
    1536 TEST(ProcessSwap, CrossSiteDownload)
    1537 {
    1538     auto processPoolConfiguration = adoptNS([[_WKProcessPoolConfiguration alloc] init]);
    1539     processPoolConfiguration.get().processSwapsOnNavigation = YES;
    1540     auto processPool = adoptNS([[WKProcessPool alloc] _initWithConfiguration:processPoolConfiguration.get()]);
    1541 
    1542     auto webViewConfiguration = adoptNS([[WKWebViewConfiguration alloc] init]);
    1543     [webViewConfiguration setProcessPool:processPool.get()];
    1544     auto handler = adoptNS([[PSONScheme alloc] init]);
    1545     [handler addMappingFromURLString:@"pson://www.google.com/main.html" toData:linkToWebKitBytes];
    1546     [handler addMappingFromURLString:@"pson://www.webkit.org/main.html" toData:"Hello"];
    1547     [webViewConfiguration setURLSchemeHandler:handler.get() forURLScheme:@"pson"];
    1548 
    1549     auto webView = adoptNS([[WKWebView alloc] initWithFrame:NSMakeRect(0, 0, 800, 600) configuration:webViewConfiguration.get()]);
    1550     auto navigationDelegate = adoptNS([[PSONNavigationDelegate alloc] init]);
    1551     [webView setNavigationDelegate:navigationDelegate.get()];
    1552 
    1553     NSURLRequest *request = [NSURLRequest requestWithURL:[NSURL URLWithString:@"pson://www.google.com/main.html"]];
    1554     [webView loadRequest:request];
    1555 
    1556     TestWebKitAPI::Util::run(&done);
    1557     done = false;
    1558     auto pidAfterFirstLoad = [webView _webProcessIdentifier];
    1559 
    1560     shouldConvertToDownload = true;
    1561     [webView evaluateJavaScript:@"testLink.click()" completionHandler:nil];
    1562 
    1563     TestWebKitAPI::Util::run(&failed);
    1564     failed = false;
    1565     shouldConvertToDownload = false;
    1566 
    1567     // We should still be on google.com.
    1568     EXPECT_EQ(pidAfterFirstLoad, [webView _webProcessIdentifier]);
    1569     EXPECT_WK_STREQ(@"pson://www.google.com/main.html", [[webView URL] absoluteString]);
    1570 
    1571     [webView evaluateJavaScript:@"testLink.innerText" completionHandler: [&] (id innerText, NSError *error) {
    1572         EXPECT_WK_STREQ(@"Link", innerText);
    1573         done = true;
    1574     }];
    1575     TestWebKitAPI::Util::run(&done);
    1576     done = false;
    15771468}
    15781469
     
    23422233    EXPECT_EQ(7u, [receivedMessages count]);
    23432234    EXPECT_WK_STREQ(@"pson://www.webkit.org/main.html - pageshow NOT persisted", receivedMessages.get()[0]);
    2344     if ([receivedMessages.get()[1] hasPrefix:@"pson://www.webkit.org/main.html"]) {
    2345         EXPECT_WK_STREQ(@"pson://www.webkit.org/main.html - pagehide persisted", receivedMessages.get()[1]);
    2346         EXPECT_WK_STREQ(@"pson://www.apple.com/main.html - pageshow NOT persisted", receivedMessages.get()[2]);
    2347     } else {
    2348         EXPECT_WK_STREQ(@"pson://www.apple.com/main.html - pageshow NOT persisted", receivedMessages.get()[1]);
    2349         EXPECT_WK_STREQ(@"pson://www.webkit.org/main.html - pagehide persisted", receivedMessages.get()[2]);
    2350     }
    2351     if ([receivedMessages.get()[3] hasPrefix:@"pson://www.apple.com/main.html"]) {
    2352         EXPECT_WK_STREQ(@"pson://www.apple.com/main.html - pagehide persisted", receivedMessages.get()[3]);
    2353         EXPECT_WK_STREQ(@"pson://www.webkit.org/main.html - pageshow persisted", receivedMessages.get()[4]);
    2354     } else {
    2355         EXPECT_WK_STREQ(@"pson://www.webkit.org/main.html - pageshow persisted", receivedMessages.get()[3]);
    2356         EXPECT_WK_STREQ(@"pson://www.apple.com/main.html - pagehide persisted", receivedMessages.get()[4]);
    2357     }
    2358     if ([receivedMessages.get()[5] hasPrefix:@"pson://www.webkit.org/main.html"]) {
    2359         EXPECT_WK_STREQ(@"pson://www.webkit.org/main.html - pagehide persisted", receivedMessages.get()[5]);
    2360         EXPECT_WK_STREQ(@"pson://www.apple.com/main.html - pageshow persisted", receivedMessages.get()[6]);
    2361     } else {
    2362         EXPECT_WK_STREQ(@"pson://www.apple.com/main.html - pageshow persisted", receivedMessages.get()[5]);
    2363         EXPECT_WK_STREQ(@"pson://www.webkit.org/main.html - pagehide persisted", receivedMessages.get()[6]);
    2364     }
     2235    EXPECT_WK_STREQ(@"pson://www.webkit.org/main.html - pagehide persisted", receivedMessages.get()[1]);
     2236    EXPECT_WK_STREQ(@"pson://www.apple.com/main.html - pageshow NOT persisted", receivedMessages.get()[2]);
     2237    EXPECT_WK_STREQ(@"pson://www.apple.com/main.html - pagehide persisted", receivedMessages.get()[3]);
     2238    EXPECT_WK_STREQ(@"pson://www.webkit.org/main.html - pageshow persisted", receivedMessages.get()[4]);
     2239    EXPECT_WK_STREQ(@"pson://www.webkit.org/main.html - pagehide persisted", receivedMessages.get()[5]);
     2240    EXPECT_WK_STREQ(@"pson://www.apple.com/main.html - pageshow persisted", receivedMessages.get()[6]);
    23652241}
    23662242
     
    24322308    EXPECT_EQ(7u, [receivedMessages count]);
    24332309    EXPECT_WK_STREQ(@"pson://www.webkit.org/main.html - load", receivedMessages.get()[0]);
    2434     if ([receivedMessages.get()[1] hasPrefix:@"pson://www.webkit.org/main.html"]) {
    2435         EXPECT_WK_STREQ(@"pson://www.webkit.org/main.html - unload", receivedMessages.get()[1]);
    2436         EXPECT_WK_STREQ(@"pson://www.apple.com/main.html - load", receivedMessages.get()[2]);
    2437     } else {
    2438         EXPECT_WK_STREQ(@"pson://www.apple.com/main.html - load", receivedMessages.get()[1]);
    2439         EXPECT_WK_STREQ(@"pson://www.webkit.org/main.html - unload", receivedMessages.get()[2]);
    2440     }
    2441     if ([receivedMessages.get()[3] hasPrefix:@"pson://www.apple.com/main.html"]) {
    2442         EXPECT_WK_STREQ(@"pson://www.apple.com/main.html - unload", receivedMessages.get()[3]);
    2443         EXPECT_WK_STREQ(@"pson://www.webkit.org/main.html - load", receivedMessages.get()[4]);
    2444     } else {
    2445         EXPECT_WK_STREQ(@"pson://www.webkit.org/main.html - load", receivedMessages.get()[3]);
    2446         EXPECT_WK_STREQ(@"pson://www.apple.com/main.html - unload", receivedMessages.get()[4]);
    2447     }
    2448     if ([receivedMessages.get()[5] hasPrefix:@"pson://www.webkit.org/main.html"]) {
    2449         EXPECT_WK_STREQ(@"pson://www.webkit.org/main.html - unload", receivedMessages.get()[5]);
    2450         EXPECT_WK_STREQ(@"pson://www.apple.com/main.html - load", receivedMessages.get()[6]);
    2451     } else {
    2452         EXPECT_WK_STREQ(@"pson://www.apple.com/main.html - load", receivedMessages.get()[5]);
    2453         EXPECT_WK_STREQ(@"pson://www.webkit.org/main.html - unload", receivedMessages.get()[6]);
    2454     }
     2310    EXPECT_WK_STREQ(@"pson://www.webkit.org/main.html - unload", receivedMessages.get()[1]);
     2311    EXPECT_WK_STREQ(@"pson://www.apple.com/main.html - load", receivedMessages.get()[2]);
     2312    EXPECT_WK_STREQ(@"pson://www.apple.com/main.html - unload", receivedMessages.get()[3]);
     2313    EXPECT_WK_STREQ(@"pson://www.webkit.org/main.html - load", receivedMessages.get()[4]);
     2314    EXPECT_WK_STREQ(@"pson://www.webkit.org/main.html - unload", receivedMessages.get()[5]);
     2315    EXPECT_WK_STREQ(@"pson://www.apple.com/main.html - load", receivedMessages.get()[6]);
    24552316}
    24562317
Note: See TracChangeset for help on using the changeset viewer.