Changeset 258628 in webkit


Ignore:
Timestamp:
Mar 18, 2020 6:59:23 AM (4 years ago)
Author:
youenn@apple.com
Message:

Source/WebCore:
FrameLoader should own its FrameLoaderClient
https://bugs.webkit.org/show_bug.cgi?id=208918

Reviewed by Geoff Garen.

Update Frame/FrameLoader constructors to get a UniqueRef<FrameLoaderClient>.
This makes the lifetime management much clearer and allows some WebKit1/WebKit2 clean-up.

Covered by existing tests.

  • loader/EmptyClients.cpp:

(WebCore::pageConfigurationWithEmptyClients):

  • loader/EmptyFrameLoaderClient.h:
  • loader/FrameLoader.cpp:

(WebCore::FrameLoader::FrameLoader):
(WebCore::FrameLoader::~FrameLoader):
(WebCore::FrameLoader::init):
(WebCore::FrameLoader::initForSynthesizedDocument):
(WebCore::FrameLoader::didExplicitOpen):
(WebCore::FrameLoader::receivedFirstData):
(WebCore::FrameLoader::finishedParsing):
(WebCore::FrameLoader::loadArchive):
(WebCore::FrameLoader::setOpener):
(WebCore::FrameLoader::provisionalLoadStarted):
(WebCore::FrameLoader::loadInSameDocument):
(WebCore::FrameLoader::prepareForLoadStart):
(WebCore::FrameLoader::setupForReplace):
(WebCore::FrameLoader::load):
(WebCore::FrameLoader::loadWithNavigationAction):
(WebCore::FrameLoader::loadWithDocumentLoader):
(WebCore::FrameLoader::willLoadMediaElementURL):
(WebCore::FrameLoader::reloadWithOverrideEncoding):
(WebCore::FrameLoader::reload):
(WebCore::FrameLoader::setDocumentLoader):
(WebCore::FrameLoader::commitProvisionalLoad):
(WebCore::FrameLoader::transitionToCommitted):
(WebCore::FrameLoader::clientRedirectCancelledOrFinished):
(WebCore::FrameLoader::clientRedirected):
(WebCore::FrameLoader::closeOldDataSources):
(WebCore::FrameLoader::willChangeTitle):
(WebCore::FrameLoader::dispatchDidFailProvisionalLoad):
(WebCore::FrameLoader::checkLoadCompleteForThisFrame):
(WebCore::FrameLoader::didReachLayoutMilestone):
(WebCore::FrameLoader::didReachVisuallyNonEmptyState):
(WebCore::FrameLoader::frameLoadCompleted):
(WebCore::FrameLoader::checkLoadComplete):
(WebCore::FrameLoader::userAgent const):
(WebCore::FrameLoader::dispatchOnloadEvents):
(WebCore::FrameLoader::detachViewsAndDocumentLoader):
(WebCore::FrameLoader::receivedMainResourceError):
(WebCore::FrameLoader::continueLoadAfterNavigationPolicy):
(WebCore::FrameLoader::continueLoadAfterNewWindowPolicy):
(WebCore::FrameLoader::loadedResourceFromMemoryCache):
(WebCore::FrameLoader::loadDifferentDocumentItem):
(WebCore::FrameLoader::cancelledError const):
(WebCore::FrameLoader::blockedByContentBlockerError const):
(WebCore::FrameLoader::blockedError const):
(WebCore::FrameLoader::blockedByContentFilterError const):
(WebCore::FrameLoader::connectionProperties):
(WebCore::FrameLoader::dispatchDidClearWindowObjectInWorld):
(WebCore::FrameLoader::dispatchGlobalObjectAvailableInAllWorlds):
(WebCore::FrameLoader::didChangeTitle):
(WebCore::FrameLoader::dispatchDidCommitLoad):
(WebCore::FrameLoader::tellClientAboutPastMemoryCacheLoads):
(WebCore::FrameLoader::completePageTransitionIfNeeded):

  • loader/FrameLoader.h:
  • loader/FrameLoaderClient.h:
  • page/Frame.cpp:

(WebCore::Frame::Frame):
(WebCore::Frame::create):

  • page/Frame.h:
  • page/Page.cpp:

(WebCore::Page::Page):

  • page/PageConfiguration.cpp:

(WebCore::PageConfiguration::PageConfiguration):

  • page/PageConfiguration.h:
  • workers/service/context/SWContextManager.cpp:
  • workers/service/context/SWContextManager.h:

Source/WebKit:
FrameLoader should own its FrameLoaderClient
https://bugs.webkit.org/show_bug.cgi?id=208918

Reviewed by Geoff Garen.

Pass a UniqueRef to the PageConfiguration.
Update WebFrameLoaderClient according updated FrameLoaderClient interface.

WebFrame no longer needs to ref/unref itself to keep the loader client alive.
Update WebFrame construction to not need a static_cast at initialization of the main frame.

The ownership is now that a WebCore::FrameLoader owns a FrameLoaderClient who owns a WebFrame.

  • WebProcess/Network/WebLoaderStrategy.cpp:

(WebKit::WebLoaderStrategy::tryLoadingUsingURLSchemeHandler):
(WebKit::WebLoaderStrategy::scheduleLoadFromNetworkProcess):
(WebKit::WebLoaderStrategy::tryLoadingSynchronouslyUsingURLSchemeHandler):
(WebKit::WebLoaderStrategy::loadResourceSynchronously):
(WebKit::WebLoaderStrategy::startPingLoad):
(WebKit::WebLoaderStrategy::preconnectTo):

  • WebProcess/Storage/WebSWContextManagerConnection.cpp:

(WebKit::WebSWContextManagerConnection::installServiceWorker):

  • WebProcess/Storage/WebSWContextManagerConnection.h:
  • WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp:

(WebKit::WebFrameLoaderClient::WebFrameLoaderClient):
(WebKit::WebFrameLoaderClient::~WebFrameLoaderClient):
(WebKit::WebFrameLoaderClient::webPageProxyID const):
(WebKit::WebFrameLoaderClient::pageID const):
(WebKit::WebFrameLoaderClient::frameID const):
(WebKit::WebFrameLoaderClient::detachedFromParent2):
(WebKit::WebFrameLoaderClient::assignIdentifierToInitialRequest):
(WebKit::WebFrameLoaderClient::dispatchWillSendRequest):
(WebKit::WebFrameLoaderClient::shouldUseCredentialStorage):
(WebKit::WebFrameLoaderClient::dispatchDidReceiveResponse):
(WebKit::WebFrameLoaderClient::dispatchDidReceiveContentLength):
(WebKit::WebFrameLoaderClient::dispatchDidFinishLoading):
(WebKit::WebFrameLoaderClient::dispatchDidFailLoading):
(WebKit::WebFrameLoaderClient::dispatchDidDispatchOnloadEvents):
(WebKit::WebFrameLoaderClient::dispatchDidReceiveServerRedirectForProvisionalLoad):
(WebKit::WebFrameLoaderClient::dispatchDidCancelClientRedirect):
(WebKit::WebFrameLoaderClient::dispatchWillPerformClientRedirect):
(WebKit::WebFrameLoaderClient::dispatchDidChangeLocationWithinPage):
(WebKit::WebFrameLoaderClient::dispatchDidPushStateWithinPage):
(WebKit::WebFrameLoaderClient::dispatchDidReplaceStateWithinPage):
(WebKit::WebFrameLoaderClient::dispatchDidPopStateWithinPage):
(WebKit::WebFrameLoaderClient::dispatchDidStartProvisionalLoad):
(WebKit::WebFrameLoaderClient::dispatchDidReceiveTitle):
(WebKit::WebFrameLoaderClient::dispatchDidCommitLoad):
(WebKit::WebFrameLoaderClient::dispatchDidFailProvisionalLoad):
(WebKit::WebFrameLoaderClient::dispatchDidFailLoad):
(WebKit::WebFrameLoaderClient::dispatchDidFinishDocumentLoad):
(WebKit::WebFrameLoaderClient::dispatchDidFinishLoad):
(WebKit::WebFrameLoaderClient::dispatchDidReachLayoutMilestone):
(WebKit::WebFrameLoaderClient::dispatchDidLayout):
(WebKit::WebFrameLoaderClient::dispatchShow):
(WebKit::WebFrameLoaderClient::dispatchDecidePolicyForResponse):
(WebKit::WebFrameLoaderClient::dispatchDecidePolicyForNewWindowAction):
(WebKit::WebFrameLoaderClient::applyToDocumentLoader):
(WebKit::WebFrameLoaderClient::allowsContentJavaScriptFromMostRecentNavigation const):
(WebKit::WebFrameLoaderClient::dispatchDecidePolicyForNavigationAction):
(WebKit::WebFrameLoaderClient::dispatchUnableToImplementPolicy):
(WebKit::WebFrameLoaderClient::dispatchWillSendSubmitEvent):
(WebKit::WebFrameLoaderClient::dispatchWillSubmitForm):
(WebKit::WebFrameLoaderClient::willReplaceMultipartContent):
(WebKit::WebFrameLoaderClient::didReplaceMultipartContent):
(WebKit::WebFrameLoaderClient::didDisplayInsecureContent):
(WebKit::WebFrameLoaderClient::didRunInsecureContent):
(WebKit::WebFrameLoaderClient::didDetectXSS):
(WebKit::WebFrameLoaderClient::cancelledError const):
(WebKit::WebFrameLoaderClient::blockedError const):
(WebKit::WebFrameLoaderClient::blockedByContentBlockerError const):
(WebKit::WebFrameLoaderClient::cannotShowURLError const):
(WebKit::WebFrameLoaderClient::interruptedForPolicyChangeError const):
(WebKit::WebFrameLoaderClient::blockedByContentFilterError const):
(WebKit::WebFrameLoaderClient::cannotShowMIMETypeError const):
(WebKit::WebFrameLoaderClient::fileDoesNotExistError const):
(WebKit::WebFrameLoaderClient::pluginWillHandleLoadError const):
(WebKit::WebFrameLoaderClient::shouldFallBack const):
(WebKit::WebFrameLoaderClient::restoreViewState):
(WebKit::WebFrameLoaderClient::didFinishLoad):
(WebKit::WebFrameLoaderClient::userAgent const):
(WebKit::WebFrameLoaderClient::createPlugin):
(WebKit::WebFrameLoaderClient::webGLPolicyForURL const):
(WebKit::WebFrameLoaderClient::resolveWebGLPolicyForURL const):
(WebKit::WebFrameLoaderClient::objectContentType):
(WebKit::WebFrameLoaderClient::overrideMediaType const):
(WebKit::WebFrameLoaderClient::dispatchDidClearWindowObjectInWorld):
(WebKit::WebFrameLoaderClient::dispatchGlobalObjectAvailable):
(WebKit::WebFrameLoaderClient::willInjectUserScript):
(WebKit::WebFrameLoaderClient::willCacheResponse const):
(WebKit::WebFrameLoaderClient::createNetworkingContext):

  • WebProcess/WebCoreSupport/WebFrameLoaderClient.h:
  • WebProcess/WebPage/WebFrame.cpp:

(WebKit::WebFrame::initWithCoreMainFrame):
(WebKit::WebFrame::createSubframe):
(WebKit::WebFrame::WebFrame):
(WebKit::WebFrame::frameLoaderClient const):
(WebKit::WebFrame::fromCoreFrame):
(WebKit::WebFrame::didReceivePolicyDecision):

  • WebProcess/WebPage/WebFrame.h:

(WebKit::WebFrame::create):

  • WebProcess/WebPage/WebPage.cpp:

(WebKit::m_processDisplayName):

Source/WebKitLegacy/mac:
FrameLoader should own its FrameLoaderClient
https://bugs.webkit.org/show_bug.cgi?id=208918

Reviewed by Geoff Garen.

Update according new Frame/FrameLoader constructors and FrameLoaderClient interface.

  • WebCoreSupport/WebFrameLoaderClient.h:

(WebFrameLoaderClient::setWebFrame):

  • WebCoreSupport/WebFrameLoaderClient.mm:

(WebFrameLoaderClient::~WebFrameLoaderClient):
(WebFrameLoaderClient::cancelledError const):
(WebFrameLoaderClient::blockedError const):
(WebFrameLoaderClient::blockedByContentBlockerError const):
(WebFrameLoaderClient::cannotShowURLError const):
(WebFrameLoaderClient::interruptedForPolicyChangeError const):
(WebFrameLoaderClient::blockedByContentFilterError const):
(WebFrameLoaderClient::cannotShowMIMETypeError const):
(WebFrameLoaderClient::fileDoesNotExistError const):
(WebFrameLoaderClient::pluginWillHandleLoadError const):
(WebFrameLoaderClient::shouldFallBack const):
(WebFrameLoaderClient::userAgent const):

  • WebView/WebFrame.mm:

(+[WebFrame _createFrameWithPage:frameName:frameView:ownerElement:]):
(+[WebFrame _createMainFrameWithPage:frameName:frameView:]):
(+[WebFrame _createMainFrameWithSimpleHTMLDocumentWithPage:frameView:style:]):

  • WebView/WebView.mm:

(-[WebView _commonInitializationWithFrameName:groupName:]):
(-[WebView initSimpleHTMLDocumentWithStyle:frame:preferences:groupName:]):

Source/WebKitLegacy/win:
Make sure a preflight fails if response headers are invalid
https://bugs.webkit.org/show_bug.cgi?id=208924

Reviewed by Geoff Garen.

  • WebCoreSupport/WebFrameLoaderClient.cpp:

(WebFrameLoaderClient::cancelledError const):
(WebFrameLoaderClient::blockedError const):
(WebFrameLoaderClient::blockedByContentBlockerError const):
(WebFrameLoaderClient::cannotShowURLError const):
(WebFrameLoaderClient::interruptedForPolicyChangeError const):
(WebFrameLoaderClient::cannotShowMIMETypeError const):
(WebFrameLoaderClient::fileDoesNotExistError const):
(WebFrameLoaderClient::pluginWillHandleLoadError const):
(WebFrameLoaderClient::shouldFallBack const):
(WebFrameLoaderClient::userAgent const):
(WebFrameLoaderClient::frameLoaderDestroyed): Deleted.
(WebFrameLoaderClient::cancelledError): Deleted.
(WebFrameLoaderClient::blockedError): Deleted.
(WebFrameLoaderClient::blockedByContentBlockerError): Deleted.
(WebFrameLoaderClient::cannotShowURLError): Deleted.
(WebFrameLoaderClient::interruptedForPolicyChangeError): Deleted.
(WebFrameLoaderClient::cannotShowMIMETypeError): Deleted.
(WebFrameLoaderClient::fileDoesNotExistError): Deleted.
(WebFrameLoaderClient::pluginWillHandleLoadError): Deleted.
(WebFrameLoaderClient::shouldFallBack): Deleted.
(WebFrameLoaderClient::userAgent): Deleted.

  • WebCoreSupport/WebFrameLoaderClient.h:
  • WebFrame.cpp:

(WebFrame::createSubframeWithOwnerElement):

Location:
trunk/Source
Files:
32 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r258626 r258628  
     12020-03-18  youenn fablet  <youenn@apple.com>
     2
     3        FrameLoader should own its FrameLoaderClient
     4        https://bugs.webkit.org/show_bug.cgi?id=208918
     5
     6        Reviewed by Geoff Garen.
     7
     8        Update Frame/FrameLoader constructors to get a UniqueRef<FrameLoaderClient>.
     9        This makes the lifetime management much clearer and allows some WebKit1/WebKit2 clean-up.
     10
     11        Covered by existing tests.
     12
     13        * loader/EmptyClients.cpp:
     14        (WebCore::pageConfigurationWithEmptyClients):
     15        * loader/EmptyFrameLoaderClient.h:
     16        * loader/FrameLoader.cpp:
     17        (WebCore::FrameLoader::FrameLoader):
     18        (WebCore::FrameLoader::~FrameLoader):
     19        (WebCore::FrameLoader::init):
     20        (WebCore::FrameLoader::initForSynthesizedDocument):
     21        (WebCore::FrameLoader::didExplicitOpen):
     22        (WebCore::FrameLoader::receivedFirstData):
     23        (WebCore::FrameLoader::finishedParsing):
     24        (WebCore::FrameLoader::loadArchive):
     25        (WebCore::FrameLoader::setOpener):
     26        (WebCore::FrameLoader::provisionalLoadStarted):
     27        (WebCore::FrameLoader::loadInSameDocument):
     28        (WebCore::FrameLoader::prepareForLoadStart):
     29        (WebCore::FrameLoader::setupForReplace):
     30        (WebCore::FrameLoader::load):
     31        (WebCore::FrameLoader::loadWithNavigationAction):
     32        (WebCore::FrameLoader::loadWithDocumentLoader):
     33        (WebCore::FrameLoader::willLoadMediaElementURL):
     34        (WebCore::FrameLoader::reloadWithOverrideEncoding):
     35        (WebCore::FrameLoader::reload):
     36        (WebCore::FrameLoader::setDocumentLoader):
     37        (WebCore::FrameLoader::commitProvisionalLoad):
     38        (WebCore::FrameLoader::transitionToCommitted):
     39        (WebCore::FrameLoader::clientRedirectCancelledOrFinished):
     40        (WebCore::FrameLoader::clientRedirected):
     41        (WebCore::FrameLoader::closeOldDataSources):
     42        (WebCore::FrameLoader::willChangeTitle):
     43        (WebCore::FrameLoader::dispatchDidFailProvisionalLoad):
     44        (WebCore::FrameLoader::checkLoadCompleteForThisFrame):
     45        (WebCore::FrameLoader::didReachLayoutMilestone):
     46        (WebCore::FrameLoader::didReachVisuallyNonEmptyState):
     47        (WebCore::FrameLoader::frameLoadCompleted):
     48        (WebCore::FrameLoader::checkLoadComplete):
     49        (WebCore::FrameLoader::userAgent const):
     50        (WebCore::FrameLoader::dispatchOnloadEvents):
     51        (WebCore::FrameLoader::detachViewsAndDocumentLoader):
     52        (WebCore::FrameLoader::receivedMainResourceError):
     53        (WebCore::FrameLoader::continueLoadAfterNavigationPolicy):
     54        (WebCore::FrameLoader::continueLoadAfterNewWindowPolicy):
     55        (WebCore::FrameLoader::loadedResourceFromMemoryCache):
     56        (WebCore::FrameLoader::loadDifferentDocumentItem):
     57        (WebCore::FrameLoader::cancelledError const):
     58        (WebCore::FrameLoader::blockedByContentBlockerError const):
     59        (WebCore::FrameLoader::blockedError const):
     60        (WebCore::FrameLoader::blockedByContentFilterError const):
     61        (WebCore::FrameLoader::connectionProperties):
     62        (WebCore::FrameLoader::dispatchDidClearWindowObjectInWorld):
     63        (WebCore::FrameLoader::dispatchGlobalObjectAvailableInAllWorlds):
     64        (WebCore::FrameLoader::didChangeTitle):
     65        (WebCore::FrameLoader::dispatchDidCommitLoad):
     66        (WebCore::FrameLoader::tellClientAboutPastMemoryCacheLoads):
     67        (WebCore::FrameLoader::completePageTransitionIfNeeded):
     68        * loader/FrameLoader.h:
     69        * loader/FrameLoaderClient.h:
     70        * page/Frame.cpp:
     71        (WebCore::Frame::Frame):
     72        (WebCore::Frame::create):
     73        * page/Frame.h:
     74        * page/Page.cpp:
     75        (WebCore::Page::Page):
     76        * page/PageConfiguration.cpp:
     77        (WebCore::PageConfiguration::PageConfiguration):
     78        * page/PageConfiguration.h:
     79        * workers/service/context/SWContextManager.cpp:
     80        * workers/service/context/SWContextManager.h:
     81
    1822020-03-18  Philippe Normand  <pnormand@igalia.com>
    283
  • trunk/Source/WebCore/loader/EmptyClients.cpp

    r258549 r258628  
    598598        CookieJar::create(adoptRef(*new EmptyStorageSessionProvider)),
    599599        makeUniqueRef<EmptyProgressTrackerClient>(),
     600        makeUniqueRef<EmptyFrameLoaderClient>(),
    600601        makeUniqueRef<EmptyMediaRecorderProvider>()
    601602    };
     
    620621    static NeverDestroyed<EmptyInspectorClient> dummyInspectorClient;
    621622    pageConfiguration.inspectorClient = &dummyInspectorClient.get();
    622 
    623     static NeverDestroyed<EmptyFrameLoaderClient> dummyFrameLoaderClient;
    624     pageConfiguration.loaderClientForMainFrame = &dummyFrameLoaderClient.get();
    625623
    626624    pageConfiguration.diagnosticLoggingClient = makeUnique<EmptyDiagnosticLoggingClient>();
  • trunk/Source/WebCore/loader/EmptyFrameLoaderClient.h

    r258549 r258628  
    3838    Ref<DocumentLoader> createDocumentLoader(const ResourceRequest&, const SubstituteData&) override;
    3939
    40     void frameLoaderDestroyed() override { }
    41 
    4240    Optional<FrameIdentifier> frameID() const override { return WTF::nullopt; }
    4341    Optional<PageIdentifier> pageID() const override { return WTF::nullopt; }
     
    127125    void finishedLoading(DocumentLoader*) final { }
    128126
    129     ResourceError cancelledError(const ResourceRequest&) final { return { ResourceError::Type::Cancellation }; }
    130     ResourceError blockedError(const ResourceRequest&) final { return { }; }
    131     ResourceError blockedByContentBlockerError(const ResourceRequest&) final { return { }; }
    132     ResourceError cannotShowURLError(const ResourceRequest&) final { return { }; }
    133     ResourceError interruptedForPolicyChangeError(const ResourceRequest&) final { return { }; }
     127    ResourceError cancelledError(const ResourceRequest&) const final { return { ResourceError::Type::Cancellation }; }
     128    ResourceError blockedError(const ResourceRequest&) const final { return { }; }
     129    ResourceError blockedByContentBlockerError(const ResourceRequest&) const final { return { }; }
     130    ResourceError cannotShowURLError(const ResourceRequest&) const final { return { }; }
     131    ResourceError interruptedForPolicyChangeError(const ResourceRequest&) const final { return { }; }
    134132#if ENABLE(CONTENT_FILTERING)
    135     ResourceError blockedByContentFilterError(const ResourceRequest&) final { return { }; }
    136 #endif
    137 
    138     ResourceError cannotShowMIMETypeError(const ResourceResponse&) final { return { }; }
    139     ResourceError fileDoesNotExistError(const ResourceResponse&) final { return { }; }
    140     ResourceError pluginWillHandleLoadError(const ResourceResponse&) final { return { }; }
    141 
    142     bool shouldFallBack(const ResourceError&) final { return false; }
     133    ResourceError blockedByContentFilterError(const ResourceRequest&) const final { return { }; }
     134#endif
     135
     136    ResourceError cannotShowMIMETypeError(const ResourceResponse&) const final { return { }; }
     137    ResourceError fileDoesNotExistError(const ResourceResponse&) const final { return { }; }
     138    ResourceError pluginWillHandleLoadError(const ResourceResponse&) const final { return { }; }
     139
     140    bool shouldFallBack(const ResourceError&) const final { return false; }
    143141
    144142    bool canHandleRequest(const ResourceRequest&) const final { return false; }
     
    157155    void setTitle(const StringWithDirection&, const URL&) final { }
    158156
    159     String userAgent(const URL&) override { return emptyString(); }
     157    String userAgent(const URL&) const override { return emptyString(); }
    160158
    161159    void savePlatformDataToCachedFrame(CachedFrame*) final { }
  • trunk/Source/WebCore/loader/FrameLoader.cpp

    r258549 r258628  
    292292};
    293293
    294 FrameLoader::FrameLoader(Frame& frame, FrameLoaderClient& client)
     294FrameLoader::FrameLoader(Frame& frame, UniqueRef<FrameLoaderClient>&& client)
    295295    : m_frame(frame)
    296     , m_client(client)
     296    , m_client(WTFMove(client))
    297297    , m_policyChecker(makeUnique<PolicyChecker>(frame))
    298298    , m_history(makeUnique<HistoryController>(frame))
     
    326326    detachFromAllOpenedFrames();
    327327
    328     m_client.frameLoaderDestroyed();
    329 
    330328    if (m_networkingContext)
    331329        m_networkingContext->invalidate();
     
    342340{
    343341    // This somewhat odd set of steps gives the frame an initial empty document.
    344     setPolicyDocumentLoader(m_client.createDocumentLoader(ResourceRequest(URL({ }, emptyString())), SubstituteData()).ptr());
     342    setPolicyDocumentLoader(m_client->createDocumentLoader(ResourceRequest(URL({ }, emptyString())), SubstituteData()).ptr());
    345343    setProvisionalDocumentLoader(m_policyDocumentLoader.get());
    346344    m_provisionalDocumentLoader->startLoadingMainResource();
     
    350348    m_stateMachine.advanceTo(FrameLoaderStateMachine::DisplayingInitialEmptyDocument);
    351349
    352     m_networkingContext = m_client.createNetworkingContext();
     350    m_networkingContext = m_client->createNetworkingContext();
    353351    m_progressTracker = makeUnique<FrameProgressTracker>(m_frame);
    354352}
     
    359357    // FrameLoader::checkCompleted() will overwrite the URL of the document to be activeDocumentLoader()->documentURL().
    360358
    361     auto loader = m_client.createDocumentLoader(ResourceRequest(URL({ }, emptyString())), SubstituteData());
     359    auto loader = m_client->createDocumentLoader(ResourceRequest(URL({ }, emptyString())), SubstituteData());
    362360    loader->attachToFrame(m_frame);
    363361    loader->setResponse(ResourceResponse(URL(), "text/html"_s, 0, String()));
     
    368366    m_stateMachine.advanceTo(FrameLoaderStateMachine::DisplayingInitialEmptyDocumentPostCommit);
    369367    m_stateMachine.advanceTo(FrameLoaderStateMachine::CommittedFirstRealLoad);
    370     m_client.transitionToCommittedForNewPage();
     368    m_client->transitionToCommittedForNewPage();
    371369
    372370    m_didCallImplicitClose = true;
     
    375373    m_needsClear = true;
    376374
    377     m_networkingContext = m_client.createNetworkingContext();
     375    m_networkingContext = m_client->createNetworkingContext();
    378376    m_progressTracker = makeUnique<FrameProgressTracker>(m_frame);
    379377}
     
    613611
    614612    if (auto* document = m_frame.document())
    615         m_client.dispatchDidExplicitOpen(document->url(), document->contentType());
     613        m_client->dispatchDidExplicitOpen(document->url(), document->contentType());
    616614   
    617615    // Prevent window.open(url) -- eg window.open("about:blank") -- from blowing away results
     
    719717    auto& title = documentLoader.title();
    720718    if (!title.string.isNull())
    721         m_client.dispatchDidReceiveTitle(title);
     719        m_client->dispatchDidReceiveTitle(title);
    722720
    723721    ASSERT(m_frame.document());
     
    804802    RefPtr<Frame> protector = m_frame.view() ? &m_frame : 0;
    805803
    806     m_client.dispatchDidFinishDocumentLoad();
     804    m_client->dispatchDidFinishDocumentLoad();
    807805
    808806    scrollToFragmentWithParentBoundary(m_frame.document()->url());
     
    10091007    ResourceRequest request(mainResource->url());
    10101008
    1011     auto documentLoader = m_client.createDocumentLoader(request, substituteData);
     1009    auto documentLoader = m_client->createDocumentLoader(request, substituteData);
    10121010    documentLoader->setArchive(WTFMove(archive));
    10131011    load(documentLoader.get());
     
    10541052{
    10551053    if (m_opener && !opener)
    1056         m_client.didDisownOpener();
     1054        m_client->didDisownOpener();
    10571055
    10581056    if (m_opener) {
     
    10861084        m_stateMachine.advanceTo(FrameLoaderStateMachine::CommittedFirstRealLoad);
    10871085    m_frame.navigationScheduler().cancel(NewLoadInProgress::Yes);
    1088     m_client.provisionalLoadStarted();
     1086    m_client->provisionalLoadStarted();
    10891087
    10901088    if (m_frame.isMainFrame()) {
     
    11831181    }
    11841182
    1185     m_client.dispatchDidNavigateWithinPage();
     1183    m_client->dispatchDidNavigateWithinPage();
    11861184
    11871185    m_frame.document()->statePopped(stateObject ? Ref<SerializedScriptValue> { *stateObject } : SerializedScriptValue::nullValue());
    1188     m_client.dispatchDidPopStateWithinPage();
     1186    m_client->dispatchDidPopStateWithinPage();
    11891187   
    11901188    if (hashChange) {
    11911189        m_frame.document()->enqueueHashchangeEvent(oldURL, url);
    1192         m_client.dispatchDidChangeLocationWithinPage();
     1190        m_client->dispatchDidChangeLocationWithinPage();
    11931191    }
    11941192   
    11951193    // FrameLoaderClient::didFinishLoad() tells the internal load delegate the load finished with no error
    1196     m_client.didFinishLoad();
     1194    m_client->didFinishLoad();
    11971195}
    11981196
     
    12271225
    12281226    m_progressTracker->progressStarted();
    1229     m_client.dispatchDidStartProvisionalLoad();
     1227    m_client->dispatchDidStartProvisionalLoad();
    12301228
    12311229    if (AXObjectCache::accessibilityEnabled()) {
     
    12391237void FrameLoader::setupForReplace()
    12401238{
    1241     m_client.revertToProvisionalState(m_documentLoader.get());
     1239    m_client->revertToProvisionalState(m_documentLoader.get());
    12421240    setState(FrameStateProvisional);
    12431241    m_provisionalDocumentLoader = m_documentLoader;
     
    14821480        request.setSubstituteData(defaultSubstituteDataForURL(request.resourceRequest().url()));
    14831481
    1484     Ref<DocumentLoader> loader = m_client.createDocumentLoader(request.resourceRequest(), request.substituteData());
     1482    Ref<DocumentLoader> loader = m_client->createDocumentLoader(request.resourceRequest(), request.substituteData());
    14851483    loader->setAllowsWebArchiveForMainFrame(request.isRequestFromClientOrUserInput());
    14861484    loader->setAllowsDataURLsForMainFrame(request.isRequestFromClientOrUserInput());
     
    15041502    FRAMELOADER_RELEASE_LOG_IF_ALLOWED(ResourceLoading, "loadWithNavigationAction: frame load started");
    15051503
    1506     Ref<DocumentLoader> loader = m_client.createDocumentLoader(request, defaultSubstituteDataForURL(request.url()));
     1504    Ref<DocumentLoader> loader = m_client->createDocumentLoader(request, defaultSubstituteDataForURL(request.url()));
    15071505    loader->setDownloadAttribute(downloadAttribute);
    15081506    applyShouldOpenExternalURLsPolicyToNewDocumentLoader(m_frame, loader, action.initiatedByMainFrame(), action.shouldOpenExternalURLsPolicy());
     
    15681566    CompletionHandlerCallingScope completionHandlerCaller(WTFMove(completionHandler));
    15691567
    1570     ASSERT(m_client.hasWebView());
     1568    ASSERT(m_client->hasWebView());
    15711569
    15721570    // Unfortunately the view must be non-nil, this is ultimately due
     
    17001698    // doesn't let them tell when a load request is coming from a media element. See <rdar://problem/8266916> for more details.
    17011699    if (IOSApplication::isMobileStore())
    1702         return m_client.shouldLoadMediaElementURL(url);
     1700        return m_client->shouldLoadMediaElementURL(url);
    17031701#endif
    17041702
     
    17531751    request.setCachePolicy(ResourceRequestCachePolicy::ReturnCacheDataElseLoad);
    17541752
    1755     Ref<DocumentLoader> loader = m_client.createDocumentLoader(request, defaultSubstituteDataForURL(request.url()));
     1753    Ref<DocumentLoader> loader = m_client->createDocumentLoader(request, defaultSubstituteDataForURL(request.url()));
    17561754    applyShouldOpenExternalURLsPolicyToNewDocumentLoader(m_frame, loader, InitiatedByMainFrame::Unknown, m_documentLoader->shouldOpenExternalURLsPolicyToPropagate());
    17571755
     
    17831781    // Create a new document loader for the reload, this will become m_documentLoader eventually,
    17841782    // but first it has to be the "policy" document loader, and then the "provisional" document loader.
    1785     Ref<DocumentLoader> loader = m_client.createDocumentLoader(initialRequest, defaultSubstituteDataForURL(initialRequest.url()));
     1783    Ref<DocumentLoader> loader = m_client->createDocumentLoader(initialRequest, defaultSubstituteDataForURL(initialRequest.url()));
    17861784    loader->setAllowsWebArchiveForMainFrame(m_documentLoader->allowsWebArchiveForMainFrame());
    17871785    loader->setAllowsDataURLsForMainFrame(m_documentLoader->allowsDataURLsForMainFrame());
     
    19451943    ASSERT(!loader || loader->frameLoader() == this);
    19461944
    1947     m_client.prepareForDataSourceReplacement();
     1945    m_client->prepareForDataSourceReplacement();
    19481946    detachChildren();
    19491947
     
    20452043
    20462044    if (!cachedPage && !m_stateMachine.creatingInitialEmptyDocument())
    2047         m_client.makeRepresentation(pdl.get());
     2045        m_client->makeRepresentation(pdl.get());
    20482046
    20492047    transitionToCommitted(cachedPage.get());
     
    20942092        auto& title = m_documentLoader->title();
    20952093        if (!title.string.isNull())
    2096             m_client.dispatchDidReceiveTitle(title);
     2094            m_client->dispatchDidReceiveTitle(title);
    20972095
    20982096        // Send remaining notifications for the main resource.
     
    21182116        // Force a layout to update view size and thereby update scrollbars.
    21192117#if PLATFORM(IOS_FAMILY)
    2120         if (!m_client.forceLayoutOnRestoreFromBackForwardCache())
     2118        if (!m_client->forceLayoutOnRestoreFromBackForwardCache())
    21212119            m_frame.view()->forceLayout();
    21222120#else
     
    21452143void FrameLoader::transitionToCommitted(CachedPage* cachedPage)
    21462144{
    2147     ASSERT(m_client.hasWebView());
     2145    ASSERT(m_client->hasWebView());
    21482146    ASSERT(m_state == FrameStateProvisional);
    21492147
     
    21562154    }
    21572155
    2158     m_client.setCopiesOnScroll();
     2156    m_client->setCopiesOnScroll();
    21592157    history().updateForCommit();
    21602158
     
    22102208                ASSERT(cachedDocumentLoader);
    22112209                cachedDocumentLoader->attachToFrame(m_frame);
    2212                 m_client.transitionToCommittedFromCachedFrame(cachedPage->cachedMainFrame());
     2210                m_client->transitionToCommittedFromCachedFrame(cachedPage->cachedMainFrame());
    22132211            } else
    2214                 m_client.transitionToCommittedForNewPage();
     2212                m_client->transitionToCommittedForNewPage();
    22152213        }
    22162214        break;
     
    22222220    case FrameLoadType::Replace:
    22232221        history().updateForReload();
    2224         m_client.transitionToCommittedForNewPage();
     2222        m_client->transitionToCommittedForNewPage();
    22252223        break;
    22262224
     
    22292227        if (m_frame.view())
    22302228            m_frame.view()->setScrollbarsSuppressed(true);
    2231         m_client.transitionToCommittedForNewPage();
     2229        m_client->transitionToCommittedForNewPage();
    22322230        break;
    22332231
    22342232    case FrameLoadType::RedirectWithLockedBackForwardList:
    22352233        history().updateForRedirectWithLockedBackForwardList();
    2236         m_client.transitionToCommittedForNewPage();
     2234        m_client->transitionToCommittedForNewPage();
    22372235        break;
    22382236    }
     
    22552253    // the redirect succeeded.  We should either rename this API, or add a new method, like
    22562254    // -webView:didFinishClientRedirectForFrame:
    2257     m_client.dispatchDidCancelClientRedirect();
     2255    m_client->dispatchDidCancelClientRedirect();
    22582256
    22592257    if (newLoadInProgress == NewLoadInProgress::No)
     
    22652263void FrameLoader::clientRedirected(const URL& url, double seconds, WallTime fireDate, LockBackForwardList lockBackForwardList)
    22662264{
    2267     m_client.dispatchWillPerformClientRedirect(url, seconds, fireDate, lockBackForwardList);
     2265    m_client->dispatchWillPerformClientRedirect(url, seconds, fireDate, lockBackForwardList);
    22682266   
    22692267    // Remember that we sent a redirect notification to the frame load delegate so that when we commit
     
    22972295   
    22982296    if (m_documentLoader)
    2299         m_client.dispatchWillClose();
    2300 
    2301     m_client.setMainFrameDocumentReady(false); // stop giving out the actual DOMDocument to observers
     2297        m_client->dispatchWillClose();
     2298
     2299    m_client->setMainFrameDocumentReady(false); // stop giving out the actual DOMDocument to observers
    23022300}
    23032301
     
    24142412void FrameLoader::willChangeTitle(DocumentLoader* loader)
    24152413{
    2416     m_client.willChangeTitle(loader);
     2414    m_client->willChangeTitle(loader);
    24172415}
    24182416
     
    24862484#endif
    24872485
    2488     m_client.dispatchDidFailProvisionalLoad(error, willContinueLoading);
     2486    m_client->dispatchDidFailProvisionalLoad(error, willContinueLoading);
    24892487
    24902488#if ENABLE(CONTENT_FILTERING)
     
    24982496void FrameLoader::checkLoadCompleteForThisFrame()
    24992497{
    2500     ASSERT(m_client.hasWebView());
     2498    ASSERT(m_client->hasWebView());
    25012499
    25022500    // FIXME: Should this check be done in checkLoadComplete instead of here?
     
    25712569            // the new page is ready.
    25722570
    2573             m_client.forceLayoutForNonHTML();
     2571            m_client->forceLayoutForNonHTML();
    25742572             
    25752573            // If the user had a scroll point, scroll to it, overriding the anchor point if any.
     
    25962594            if (!error.isNull()) {
    25972595                FRAMELOADER_RELEASE_LOG_IF_ALLOWED(ResourceLoading, "checkLoadCompleteForThisFrame: Finished frame load with error (isTimeout = %d, isCancellation = %d, errorCode = %d)", error.isTimeout(), error.isCancellation(), error.errorCode());
    2598                 m_client.dispatchDidFailLoad(error);
     2596                m_client->dispatchDidFailLoad(error);
    25992597                loadingEvent = AXObjectCache::AXLoadingFailed;
    26002598            } else {
     
    26052603                    if (auto* documentElement = document->documentElement()) {
    26062604                        RefPtr<Range> documentRange = makeRange(firstPositionInNode(documentElement), lastPositionInNode(documentElement));
    2607                         m_frame.setDataDetectionResults(DataDetection::detectContentInRange(documentRange, m_frame.settings().dataDetectorTypes(), m_client.dataDetectionContext()));
     2605                        m_frame.setDataDetectionResults(DataDetection::detectContentInRange(documentRange, m_frame.settings().dataDetectorTypes(), m_client->dataDetectionContext()));
    26082606                        if (m_frame.isMainFrame())
    2609                             m_client.dispatchDidFinishDataDetection(m_frame.dataDetectionResults());
     2607                            m_client->dispatchDidFinishDataDetection(m_frame.dataDetectionResults());
    26102608                    }
    26112609                }
    26122610#endif
    2613                 m_client.dispatchDidFinishLoad();
     2611                m_client->dispatchDidFinishLoad();
    26142612                loadingEvent = AXObjectCache::AXLoadingFinished;
    26152613            }
     
    26692667    ASSERT(m_frame.isMainFrame());
    26702668
    2671     m_client.dispatchDidReachLayoutMilestone(milestones);
     2669    m_client->dispatchDidReachLayoutMilestone(milestones);
    26722670}
    26732671
     
    26912689{
    26922690    ASSERT(m_frame.isMainFrame());
    2693     m_client.dispatchDidReachVisuallyNonEmptyState();
     2691    m_client->dispatchDidReachVisuallyNonEmptyState();
    26942692}
    26952693
     
    26982696    // Note: Can be called multiple times.
    26992697
    2700     m_client.frameLoadCompleted();
     2698    m_client->frameLoadCompleted();
    27012699
    27022700    history().updateForFrameLoadCompleted();
     
    27572755        return;
    27582756
    2759     ASSERT(m_client.hasWebView());
     2757    ASSERT(m_client->hasWebView());
    27602758   
    27612759    // FIXME: Always traversing the entire frame tree is a bit inefficient, but
     
    27992797        return userAgent;
    28002798
    2801     return m_client.userAgent(url);
     2799    return m_client->userAgent(url);
    28022800}
    28032801
     
    28142812void FrameLoader::dispatchOnloadEvents()
    28152813{
    2816     m_client.dispatchDidDispatchOnloadEvents();
     2814    m_client->dispatchDidDispatchOnloadEvents();
    28172815
    28182816    if (documentLoader())
     
    28722870void FrameLoader::detachViewsAndDocumentLoader()
    28732871{
    2874     m_client.detachedFromParent2();
     2872    m_client->detachedFromParent2();
    28752873    setDocumentLoader(nullptr);
    2876     m_client.detachedFromParent3();
     2874    m_client->detachedFromParent3();
    28772875}
    28782876   
     
    31763174    // that both data sources on the frame are either this or nil.
    31773175    stop();
    3178     if (m_client.shouldFallBack(error))
     3176    if (m_client->shouldFallBack(error))
    31793177        handleFallbackContent();
    31803178
     
    35553553    }
    35563554
    3557     m_client.dispatchWillSubmitForm(*formState, WTFMove(completionHandler));
     3555    m_client->dispatchWillSubmitForm(*formState, WTFMove(completionHandler));
    35583556}
    35593557
     
    35653563
    35663564    Ref<Frame> frame(m_frame);
    3567     RefPtr<Frame> mainFrame = m_client.dispatchCreatePage(action);
     3565    RefPtr<Frame> mainFrame = m_client->dispatchCreatePage(action);
    35683566    if (!mainFrame)
    35693567        return;
     
    35773575
    35783576    mainFrame->page()->setOpenedByDOM();
    3579     mainFrame->loader().m_client.dispatchShow();
     3577    mainFrame->loader().m_client->dispatchShow();
    35803578    if (openerPolicy == NewFrameOpenerPolicy::Allow) {
    35813579        mainFrame->loader().setOpener(frame.ptr());
     
    36283626    }
    36293627
    3630     if (m_client.dispatchDidLoadResourceFromMemoryCache(m_documentLoader.get(), newRequest, resource.response(), resource.encodedSize())) {
     3628    if (m_client->dispatchDidLoadResourceFromMemoryCache(m_documentLoader.get(), newRequest, resource.response(), resource.encodedSize())) {
    36313629        InspectorInstrumentation::didLoadResourceFromMemoryCache(*page, m_documentLoader.get(), &resource);
    36323630        m_documentLoader->didTellClientAboutLoad(resource.url());
     
    37803778    if (CachedPage* cachedPage = BackForwardCache::singleton().get(item, m_frame.page())) {
    37813779        auto documentLoader = cachedPage->documentLoader();
    3782         m_client.updateCachedDocumentLoader(*documentLoader);
     3780        m_client->updateCachedDocumentLoader(*documentLoader);
    37833781
    37843782        auto action = NavigationAction { *m_frame.document(), documentLoader->request(), initiatedByMainFrame, loadType, false };
     
    39133911ResourceError FrameLoader::cancelledError(const ResourceRequest& request) const
    39143912{
    3915     ResourceError error = m_client.cancelledError(request);
     3913    ResourceError error = m_client->cancelledError(request);
    39163914    error.setType(ResourceError::Type::Cancellation);
    39173915    return error;
     
    39203918ResourceError FrameLoader::blockedByContentBlockerError(const ResourceRequest& request) const
    39213919{
    3922     return m_client.blockedByContentBlockerError(request);
     3920    return m_client->blockedByContentBlockerError(request);
    39233921}
    39243922
    39253923ResourceError FrameLoader::blockedError(const ResourceRequest& request) const
    39263924{
    3927     ResourceError error = m_client.blockedError(request);
     3925    ResourceError error = m_client->blockedError(request);
    39283926    error.setType(ResourceError::Type::Cancellation);
    39293927    return error;
     
    39333931ResourceError FrameLoader::blockedByContentFilterError(const ResourceRequest& request) const
    39343932{
    3935     ResourceError error = m_client.blockedByContentFilterError(request);
     3933    ResourceError error = m_client->blockedByContentFilterError(request);
    39363934    error.setType(ResourceError::Type::General);
    39373935    return error;
     
    39423940RetainPtr<CFDictionaryRef> FrameLoader::connectionProperties(ResourceLoader* loader)
    39433941{
    3944     return m_client.connectionProperties(loader->documentLoader(), loader->identifier());
     3942    return m_client->connectionProperties(loader->documentLoader(), loader->identifier());
    39453943}
    39463944#endif
     
    39763974        return;
    39773975
    3978     m_client.dispatchDidClearWindowObjectInWorld(world);
     3976    m_client->dispatchDidClearWindowObjectInWorld(world);
    39793977
    39803978    if (Page* page = m_frame.page())
     
    39893987    ScriptController::getAllWorlds(worlds);
    39903988    for (auto& world : worlds)
    3991         m_client.dispatchGlobalObjectAvailable(world);
     3989        m_client->dispatchGlobalObjectAvailable(world);
    39923990}
    39933991
     
    40044002void FrameLoader::didChangeTitle(DocumentLoader* loader)
    40054003{
    4006     m_client.didChangeTitle(loader);
     4004    m_client->didChangeTitle(loader);
    40074005
    40084006    if (loader == m_documentLoader) {
     
    40104008        history().setCurrentItemTitle(loader->title());
    40114009        // This must go through the WebFrame because it has the right notion of the current b/f item.
    4012         m_client.setTitle(loader->title(), loader->urlForHistory());
    4013         m_client.setMainFrameDocumentReady(true); // update observers with new DOMDocument
    4014         m_client.dispatchDidReceiveTitle(loader->title());
     4010        m_client->setTitle(loader->title(), loader->urlForHistory());
     4011        m_client->setMainFrameDocumentReady(true); // update observers with new DOMDocument
     4012        m_client->dispatchDidReceiveTitle(loader->title());
    40154013    }
    40164014
     
    40264024        return;
    40274025
    4028     m_client.dispatchDidCommitLoad(initialHasInsecureContent, initialUsedLegacyTLS);
     4026    m_client->dispatchDidCommitLoad(initialHasInsecureContent, initialUsedLegacyTLS);
    40294027
    40304028    if (m_frame.isMainFrame()) {
     
    40634061
    40644062        ResourceRequest request(resource->url());
    4065         m_client.dispatchDidLoadResourceFromMemoryCache(m_documentLoader.get(), request, resource->response(), resource->encodedSize());
     4063        m_client->dispatchDidLoadResourceFromMemoryCache(m_documentLoader.get(), request, resource->response(), resource->encodedSize());
    40664064    }
    40674065}
     
    40804078void FrameLoader::completePageTransitionIfNeeded()
    40814079{
    4082     m_client.completePageTransitionIfNeeded();
     4080    m_client->completePageTransitionIfNeeded();
    40834081}
    40844082
  • trunk/Source/WebCore/loader/FrameLoader.h

    r258549 r258628  
    5353#include <wtf/OptionSet.h>
    5454#include <wtf/Optional.h>
     55#include <wtf/UniqueRef.h>
    5556#include <wtf/WallTime.h>
    5657
     
    103104    WTF_MAKE_NONCOPYABLE(FrameLoader);
    104105public:
    105     FrameLoader(Frame&, FrameLoaderClient&);
     106    FrameLoader(Frame&, UniqueRef<FrameLoaderClient>&&);
    106107    ~FrameLoader();
    107108
     
    228229    static void addSameSiteInfoToRequestIfNeeded(ResourceRequest&, const Document* initiator = nullptr);
    229230
    230     FrameLoaderClient& client() const { return m_client; }
     231    const FrameLoaderClient& client() const { return m_client.get(); }
     232    FrameLoaderClient& client() { return m_client.get(); }
    231233
    232234    WEBCORE_EXPORT Optional<PageIdentifier> pageID() const;
     
    425427
    426428    Frame& m_frame;
    427     FrameLoaderClient& m_client;
     429    UniqueRef<FrameLoaderClient> m_client;
    428430
    429431    const std::unique_ptr<PolicyChecker> m_policyChecker;
  • trunk/Source/WebCore/loader/FrameLoaderClient.h

    r258549 r258628  
    121121    virtual ~FrameLoaderClient() = default;
    122122
    123     virtual void frameLoaderDestroyed() = 0;
    124 
    125123    virtual bool hasWebView() const = 0; // mainly for assertions
    126124
     
    239237    virtual void didDetectXSS(const URL&, bool didBlockEntirePage) = 0;
    240238
    241     virtual ResourceError cancelledError(const ResourceRequest&) = 0;
    242     virtual ResourceError blockedError(const ResourceRequest&) = 0;
    243     virtual ResourceError blockedByContentBlockerError(const ResourceRequest&) = 0;
    244     virtual ResourceError cannotShowURLError(const ResourceRequest&) = 0;
    245     virtual ResourceError interruptedForPolicyChangeError(const ResourceRequest&) = 0;
     239    virtual ResourceError cancelledError(const ResourceRequest&) const = 0;
     240    virtual ResourceError blockedError(const ResourceRequest&) const = 0;
     241    virtual ResourceError blockedByContentBlockerError(const ResourceRequest&) const = 0;
     242    virtual ResourceError cannotShowURLError(const ResourceRequest&) const = 0;
     243    virtual ResourceError interruptedForPolicyChangeError(const ResourceRequest&) const = 0;
    246244#if ENABLE(CONTENT_FILTERING)
    247     virtual ResourceError blockedByContentFilterError(const ResourceRequest&) = 0;
    248 #endif
    249 
    250     virtual ResourceError cannotShowMIMETypeError(const ResourceResponse&) = 0;
    251     virtual ResourceError fileDoesNotExistError(const ResourceResponse&) = 0;
    252     virtual ResourceError pluginWillHandleLoadError(const ResourceResponse&) = 0;
    253 
    254     virtual bool shouldFallBack(const ResourceError&) = 0;
     245    virtual ResourceError blockedByContentFilterError(const ResourceRequest&) const = 0;
     246#endif
     247
     248    virtual ResourceError cannotShowMIMETypeError(const ResourceResponse&) const = 0;
     249    virtual ResourceError fileDoesNotExistError(const ResourceResponse&) const = 0;
     250    virtual ResourceError pluginWillHandleLoadError(const ResourceResponse&) const = 0;
     251
     252    virtual bool shouldFallBack(const ResourceError&) const = 0;
    255253
    256254    virtual bool canHandleRequest(const ResourceRequest&) const = 0;
     
    271269    virtual void setTitle(const StringWithDirection&, const URL&) = 0;
    272270
    273     virtual String userAgent(const URL&) = 0;
     271    virtual String userAgent(const URL&) const = 0;
    274272
    275273    virtual String overrideContentSecurityPolicy() const { return String(); }
  • trunk/Source/WebCore/page/Frame.cpp

    r258549 r258628  
    144144}
    145145
    146 Frame::Frame(Page& page, HTMLFrameOwnerElement* ownerElement, FrameLoaderClient& frameLoaderClient)
     146Frame::Frame(Page& page, HTMLFrameOwnerElement* ownerElement, UniqueRef<FrameLoaderClient>&& frameLoaderClient)
    147147    : m_mainFrame(ownerElement ? page.mainFrame() : *this)
    148148    , m_page(&page)
    149149    , m_settings(&page.settings())
    150150    , m_treeNode(*this, parentFromOwnerElement(ownerElement))
    151     , m_loader(makeUniqueRef<FrameLoader>(*this, frameLoaderClient))
     151    , m_loader(makeUniqueRef<FrameLoader>(*this, WTFMove(frameLoaderClient)))
    152152    , m_navigationScheduler(makeUniqueRef<NavigationScheduler>(*this))
    153153    , m_ownerElement(ownerElement)
     
    183183}
    184184
    185 Ref<Frame> Frame::create(Page* page, HTMLFrameOwnerElement* ownerElement, FrameLoaderClient* client)
     185Ref<Frame> Frame::create(Page* page, HTMLFrameOwnerElement* ownerElement, UniqueRef<FrameLoaderClient>&& client)
    186186{
    187187    ASSERT(page);
    188     ASSERT(client);
    189     return adoptRef(*new Frame(*page, ownerElement, *client));
     188    return adoptRef(*new Frame(*page, ownerElement, WTFMove(client)));
    190189}
    191190
  • trunk/Source/WebCore/page/Frame.h

    r258549 r258628  
    127127class Frame final : public AbstractFrame {
    128128public:
    129     WEBCORE_EXPORT static Ref<Frame> create(Page*, HTMLFrameOwnerElement*, FrameLoaderClient*);
     129    WEBCORE_EXPORT static Ref<Frame> create(Page*, HTMLFrameOwnerElement*, UniqueRef<FrameLoaderClient>&&);
    130130
    131131    WEBCORE_EXPORT void init();
     
    308308    friend class NavigationDisabler;
    309309
    310     Frame(Page&, HTMLFrameOwnerElement*, FrameLoaderClient&);
     310    Frame(Page&, HTMLFrameOwnerElement*, UniqueRef<FrameLoaderClient>&&);
    311311
    312312    void dropChildren();
  • trunk/Source/WebCore/page/Page.cpp

    r258549 r258628  
    232232    , m_progress(makeUnique<ProgressTracker>(WTFMove(pageConfiguration.progressTrackerClient)))
    233233    , m_backForwardController(makeUnique<BackForwardController>(*this, WTFMove(pageConfiguration.backForwardClient)))
    234     , m_mainFrame(Frame::create(this, nullptr, pageConfiguration.loaderClientForMainFrame))
     234    , m_mainFrame(Frame::create(this, nullptr, WTFMove(pageConfiguration.loaderClientForMainFrame)))
    235235    , m_editorClient(WTFMove(pageConfiguration.editorClient))
    236236    , m_plugInClient(WTFMove(pageConfiguration.plugInClient))
  • trunk/Source/WebCore/page/PageConfiguration.cpp

    r258549 r258628  
    5757namespace WebCore {
    5858
    59 PageConfiguration::PageConfiguration(PAL::SessionID sessionID, UniqueRef<EditorClient>&& editorClient, Ref<SocketProvider>&& socketProvider, UniqueRef<LibWebRTCProvider>&& libWebRTCProvider, Ref<CacheStorageProvider>&& cacheStorageProvider, Ref<BackForwardClient>&& backForwardClient, Ref<CookieJar>&& cookieJar, UniqueRef<ProgressTrackerClient>&& progressTrackerClient, UniqueRef<MediaRecorderProvider>&& mediaRecorderProvider)
     59PageConfiguration::PageConfiguration(PAL::SessionID sessionID, UniqueRef<EditorClient>&& editorClient, Ref<SocketProvider>&& socketProvider, UniqueRef<LibWebRTCProvider>&& libWebRTCProvider, Ref<CacheStorageProvider>&& cacheStorageProvider, Ref<BackForwardClient>&& backForwardClient, Ref<CookieJar>&& cookieJar, UniqueRef<ProgressTrackerClient>&& progressTrackerClient, UniqueRef<FrameLoaderClient>&& loaderClientForMainFrame, UniqueRef<MediaRecorderProvider>&& mediaRecorderProvider)
    6060    : sessionID(sessionID)
    6161    , editorClient(WTFMove(editorClient))
     
    6565    , backForwardClient(WTFMove(backForwardClient))
    6666    , cookieJar(WTFMove(cookieJar))
     67    , loaderClientForMainFrame(WTFMove(loaderClientForMainFrame))
    6768    , cacheStorageProvider(WTFMove(cacheStorageProvider))
    6869    , mediaRecorderProvider(WTFMove(mediaRecorderProvider))
  • trunk/Source/WebCore/page/PageConfiguration.h

    r258549 r258628  
    7272    WTF_MAKE_NONCOPYABLE(PageConfiguration); WTF_MAKE_FAST_ALLOCATED;
    7373public:
    74     WEBCORE_EXPORT PageConfiguration(PAL::SessionID, UniqueRef<EditorClient>&&, Ref<SocketProvider>&&, UniqueRef<LibWebRTCProvider>&&, Ref<CacheStorageProvider>&&, Ref<BackForwardClient>&&, Ref<CookieJar>&&, UniqueRef<ProgressTrackerClient>&&, UniqueRef<MediaRecorderProvider>&&);
     74    WEBCORE_EXPORT PageConfiguration(PAL::SessionID, UniqueRef<EditorClient>&&, Ref<SocketProvider>&&, UniqueRef<LibWebRTCProvider>&&, Ref<CacheStorageProvider>&&, Ref<BackForwardClient>&&, Ref<CookieJar>&&, UniqueRef<ProgressTrackerClient>&&, UniqueRef<FrameLoaderClient>&&, UniqueRef<MediaRecorderProvider>&&);
    7575    WEBCORE_EXPORT ~PageConfiguration();
    7676    PageConfiguration(PageConfiguration&&);
     
    105105    Ref<CookieJar> cookieJar;
    106106    std::unique_ptr<ValidationMessageClient> validationMessageClient;
    107     FrameLoaderClient* loaderClientForMainFrame { nullptr };
     107    UniqueRef<FrameLoaderClient> loaderClientForMainFrame;
    108108    std::unique_ptr<DiagnosticLoggingClient> diagnosticLoggingClient;
    109109    std::unique_ptr<PerformanceLoggingClient> performanceLoggingClient;
  • trunk/Source/WebCore/workers/service/context/SWContextManager.cpp

    r258549 r258628  
    183183}
    184184
    185 void SWContextManager::addServiceWorkerFrameLoaderClient(std::unique_ptr<FrameLoaderClient>&& client)
    186 {
    187     m_serviceWorkerFrameLoaderClients.add(WTFMove(client));
    188 }
    189 
    190 void SWContextManager::removeServiceWorkerFrameLoaderClient(FrameLoaderClient& client)
    191 {
    192     ASSERT(m_serviceWorkerFrameLoaderClients.contains(&client));
    193     m_serviceWorkerFrameLoaderClients.remove(&client);
    194 }
    195 
    196185} // namespace WebCore
    197186
  • trunk/Source/WebCore/workers/service/context/SWContextManager.h

    r258549 r258628  
    3838namespace WebCore {
    3939
    40 class FrameLoaderClient;
    4140class SerializedScriptValue;
    4241class ServiceWorkerGlobalScope;
     
    104103    WEBCORE_EXPORT void stopAllServiceWorkers();
    105104
    106     WEBCORE_EXPORT void addServiceWorkerFrameLoaderClient(std::unique_ptr<FrameLoaderClient>&&);
    107     WEBCORE_EXPORT void removeServiceWorkerFrameLoaderClient(FrameLoaderClient&);
    108 
    109105    static constexpr Seconds workerTerminationTimeout { 10_s };
    110106    static constexpr Seconds syncWorkerTerminationTimeout { 100_ms }; // Only used by layout tests.
     
    131127    };
    132128    HashMap<ServiceWorkerIdentifier, std::unique_ptr<ServiceWorkerTerminationRequest>> m_pendingServiceWorkerTerminationRequests;
    133     HashSet<std::unique_ptr<FrameLoaderClient>> m_serviceWorkerFrameLoaderClients;
    134129};
    135130
  • trunk/Source/WebKit/ChangeLog

    r258620 r258628  
     12020-03-18  youenn fablet  <youenn@apple.com>
     2
     3        FrameLoader should own its FrameLoaderClient
     4        https://bugs.webkit.org/show_bug.cgi?id=208918
     5
     6        Reviewed by Geoff Garen.
     7
     8        Pass a UniqueRef to the PageConfiguration.
     9        Update WebFrameLoaderClient according updated FrameLoaderClient interface.
     10
     11        WebFrame no longer needs to ref/unref itself to keep the loader client alive.
     12        Update WebFrame construction to not need a static_cast at initialization of the main frame.
     13
     14        The ownership is now that a WebCore::FrameLoader owns a FrameLoaderClient who owns a WebFrame.
     15
     16        * WebProcess/Network/WebLoaderStrategy.cpp:
     17        (WebKit::WebLoaderStrategy::tryLoadingUsingURLSchemeHandler):
     18        (WebKit::WebLoaderStrategy::scheduleLoadFromNetworkProcess):
     19        (WebKit::WebLoaderStrategy::tryLoadingSynchronouslyUsingURLSchemeHandler):
     20        (WebKit::WebLoaderStrategy::loadResourceSynchronously):
     21        (WebKit::WebLoaderStrategy::startPingLoad):
     22        (WebKit::WebLoaderStrategy::preconnectTo):
     23        * WebProcess/Storage/WebSWContextManagerConnection.cpp:
     24        (WebKit::WebSWContextManagerConnection::installServiceWorker):
     25        * WebProcess/Storage/WebSWContextManagerConnection.h:
     26        * WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp:
     27        (WebKit::WebFrameLoaderClient::WebFrameLoaderClient):
     28        (WebKit::WebFrameLoaderClient::~WebFrameLoaderClient):
     29        (WebKit::WebFrameLoaderClient::webPageProxyID const):
     30        (WebKit::WebFrameLoaderClient::pageID const):
     31        (WebKit::WebFrameLoaderClient::frameID const):
     32        (WebKit::WebFrameLoaderClient::detachedFromParent2):
     33        (WebKit::WebFrameLoaderClient::assignIdentifierToInitialRequest):
     34        (WebKit::WebFrameLoaderClient::dispatchWillSendRequest):
     35        (WebKit::WebFrameLoaderClient::shouldUseCredentialStorage):
     36        (WebKit::WebFrameLoaderClient::dispatchDidReceiveResponse):
     37        (WebKit::WebFrameLoaderClient::dispatchDidReceiveContentLength):
     38        (WebKit::WebFrameLoaderClient::dispatchDidFinishLoading):
     39        (WebKit::WebFrameLoaderClient::dispatchDidFailLoading):
     40        (WebKit::WebFrameLoaderClient::dispatchDidDispatchOnloadEvents):
     41        (WebKit::WebFrameLoaderClient::dispatchDidReceiveServerRedirectForProvisionalLoad):
     42        (WebKit::WebFrameLoaderClient::dispatchDidCancelClientRedirect):
     43        (WebKit::WebFrameLoaderClient::dispatchWillPerformClientRedirect):
     44        (WebKit::WebFrameLoaderClient::dispatchDidChangeLocationWithinPage):
     45        (WebKit::WebFrameLoaderClient::dispatchDidPushStateWithinPage):
     46        (WebKit::WebFrameLoaderClient::dispatchDidReplaceStateWithinPage):
     47        (WebKit::WebFrameLoaderClient::dispatchDidPopStateWithinPage):
     48        (WebKit::WebFrameLoaderClient::dispatchDidStartProvisionalLoad):
     49        (WebKit::WebFrameLoaderClient::dispatchDidReceiveTitle):
     50        (WebKit::WebFrameLoaderClient::dispatchDidCommitLoad):
     51        (WebKit::WebFrameLoaderClient::dispatchDidFailProvisionalLoad):
     52        (WebKit::WebFrameLoaderClient::dispatchDidFailLoad):
     53        (WebKit::WebFrameLoaderClient::dispatchDidFinishDocumentLoad):
     54        (WebKit::WebFrameLoaderClient::dispatchDidFinishLoad):
     55        (WebKit::WebFrameLoaderClient::dispatchDidReachLayoutMilestone):
     56        (WebKit::WebFrameLoaderClient::dispatchDidLayout):
     57        (WebKit::WebFrameLoaderClient::dispatchShow):
     58        (WebKit::WebFrameLoaderClient::dispatchDecidePolicyForResponse):
     59        (WebKit::WebFrameLoaderClient::dispatchDecidePolicyForNewWindowAction):
     60        (WebKit::WebFrameLoaderClient::applyToDocumentLoader):
     61        (WebKit::WebFrameLoaderClient::allowsContentJavaScriptFromMostRecentNavigation const):
     62        (WebKit::WebFrameLoaderClient::dispatchDecidePolicyForNavigationAction):
     63        (WebKit::WebFrameLoaderClient::dispatchUnableToImplementPolicy):
     64        (WebKit::WebFrameLoaderClient::dispatchWillSendSubmitEvent):
     65        (WebKit::WebFrameLoaderClient::dispatchWillSubmitForm):
     66        (WebKit::WebFrameLoaderClient::willReplaceMultipartContent):
     67        (WebKit::WebFrameLoaderClient::didReplaceMultipartContent):
     68        (WebKit::WebFrameLoaderClient::didDisplayInsecureContent):
     69        (WebKit::WebFrameLoaderClient::didRunInsecureContent):
     70        (WebKit::WebFrameLoaderClient::didDetectXSS):
     71        (WebKit::WebFrameLoaderClient::cancelledError const):
     72        (WebKit::WebFrameLoaderClient::blockedError const):
     73        (WebKit::WebFrameLoaderClient::blockedByContentBlockerError const):
     74        (WebKit::WebFrameLoaderClient::cannotShowURLError const):
     75        (WebKit::WebFrameLoaderClient::interruptedForPolicyChangeError const):
     76        (WebKit::WebFrameLoaderClient::blockedByContentFilterError const):
     77        (WebKit::WebFrameLoaderClient::cannotShowMIMETypeError const):
     78        (WebKit::WebFrameLoaderClient::fileDoesNotExistError const):
     79        (WebKit::WebFrameLoaderClient::pluginWillHandleLoadError const):
     80        (WebKit::WebFrameLoaderClient::shouldFallBack const):
     81        (WebKit::WebFrameLoaderClient::restoreViewState):
     82        (WebKit::WebFrameLoaderClient::didFinishLoad):
     83        (WebKit::WebFrameLoaderClient::userAgent const):
     84        (WebKit::WebFrameLoaderClient::createPlugin):
     85        (WebKit::WebFrameLoaderClient::webGLPolicyForURL const):
     86        (WebKit::WebFrameLoaderClient::resolveWebGLPolicyForURL const):
     87        (WebKit::WebFrameLoaderClient::objectContentType):
     88        (WebKit::WebFrameLoaderClient::overrideMediaType const):
     89        (WebKit::WebFrameLoaderClient::dispatchDidClearWindowObjectInWorld):
     90        (WebKit::WebFrameLoaderClient::dispatchGlobalObjectAvailable):
     91        (WebKit::WebFrameLoaderClient::willInjectUserScript):
     92        (WebKit::WebFrameLoaderClient::willCacheResponse const):
     93        (WebKit::WebFrameLoaderClient::createNetworkingContext):
     94        * WebProcess/WebCoreSupport/WebFrameLoaderClient.h:
     95        * WebProcess/WebPage/WebFrame.cpp:
     96        (WebKit::WebFrame::initWithCoreMainFrame):
     97        (WebKit::WebFrame::createSubframe):
     98        (WebKit::WebFrame::WebFrame):
     99        (WebKit::WebFrame::frameLoaderClient const):
     100        (WebKit::WebFrame::fromCoreFrame):
     101        (WebKit::WebFrame::didReceivePolicyDecision):
     102        * WebProcess/WebPage/WebFrame.h:
     103        (WebKit::WebFrame::create):
     104        * WebProcess/WebPage/WebPage.cpp:
     105        (WebKit::m_processDisplayName):
     106
    11072020-03-17  David Kilzer  <ddkilzer@apple.com>
    2108
  • trunk/Source/WebKit/WebProcess/Network/WebLoaderStrategy.cpp

    r258549 r258628  
    244244        return false;
    245245
    246     auto* webFrame = webFrameLoaderClient->webFrame();
    247     if (!webFrame)
    248         return false;
    249 
    250     auto* webPage = webFrame->page();
     246    auto& webFrame = webFrameLoaderClient->webFrame();
     247    auto* webPage = webFrame.page();
    251248    if (!webPage)
    252249        return false;
     
    259256    WEBLOADERSTRATEGY_RELEASE_LOG_IF_ALLOWED("tryLoadingUsingURLSchemeHandler: URL will be handled by a UIProcess URL scheme handler");
    260257
    261     handler->startNewTask(resourceLoader, *webFrame);
     258    handler->startNewTask(resourceLoader, webFrame);
    262259    return true;
    263260}
     
    331328   
    332329    auto* webFrameLoaderClient = frame ? toWebFrameLoaderClient(frame->loader().client()) : nullptr;
    333     auto* webFrame = webFrameLoaderClient ? webFrameLoaderClient->webFrame() : nullptr;
     330    auto* webFrame = webFrameLoaderClient ? &webFrameLoaderClient->webFrame() : nullptr;
    334331    auto* webPage = webFrame ? webFrame->page() : nullptr;
    335332    if (webPage)
     
    534531{
    535532    auto* webFrameLoaderClient = toWebFrameLoaderClient(frameLoader.client());
    536     auto* webFrame = webFrameLoaderClient ? webFrameLoaderClient->webFrame() : nullptr;
     533    auto* webFrame = webFrameLoaderClient ? &webFrameLoaderClient->webFrame() : nullptr;
    537534    auto* webPage = webFrame ? webFrame->page() : nullptr;
    538535    if (!webPage)
     
    554551{
    555552    auto* webFrameLoaderClient = toWebFrameLoaderClient(frameLoader.client());
    556     auto* webFrame = webFrameLoaderClient ? webFrameLoaderClient->webFrame() : nullptr;
     553    auto* webFrame = webFrameLoaderClient ? &webFrameLoaderClient->webFrame() : nullptr;
    557554    auto* webPage = webFrame ? webFrame->page() : nullptr;
    558555    auto* page = webPage ? webPage->corePage() : nullptr;
     
    687684   
    688685    auto* webFrameLoaderClient = toWebFrameLoaderClient(frame.loader().client());
    689     auto* webFrame = webFrameLoaderClient ? webFrameLoaderClient->webFrame() : nullptr;
     686    auto* webFrame = webFrameLoaderClient ? &webFrameLoaderClient->webFrame() : nullptr;
    690687    auto* webPage = webFrame ? webFrame->page() : nullptr;
    691688    if (webPage)
     
    719716        return;
    720717    }
    721     auto* webFrame = webFrameLoaderClient->webFrame();
    722     if (!webFrame) {
    723         completionHandler(internalError(url));
    724         return;
    725     }
    726     auto* webPage = webFrame->page();
     718    auto& webFrame = webFrameLoaderClient->webFrame();
     719    auto* webPage = webFrame.page();
    727720    if (!webPage) {
    728721        completionHandler(internalError(url));
     
    730723    }
    731724
    732     preconnectTo(ResourceRequest { url }, *webPage, *webFrame, storedCredentialsPolicy, WTFMove(completionHandler));
     725    preconnectTo(ResourceRequest { url }, *webPage, webFrame, storedCredentialsPolicy, WTFMove(completionHandler));
    733726}
    734727
  • trunk/Source/WebKit/WebProcess/Storage/WebSWContextManagerConnection.cpp

    r258549 r258628  
    7474
    7575
    76 ServiceWorkerFrameLoaderClient& ServiceWorkerFrameLoaderClient::create(WebPageProxyIdentifier webPageProxyID, PageIdentifier pageID, FrameIdentifier frameID, const String& userAgent)
    77 {
    78     auto frameLoaderClient = std::unique_ptr<ServiceWorkerFrameLoaderClient>(new ServiceWorkerFrameLoaderClient(webPageProxyID, pageID, frameID, userAgent));
    79     auto& client = *frameLoaderClient;
    80     SWContextManager::singleton().addServiceWorkerFrameLoaderClient(WTFMove(frameLoaderClient));
    81     return client;
    82 }
    83 
    8476ServiceWorkerFrameLoaderClient::ServiceWorkerFrameLoaderClient(WebPageProxyIdentifier webPageProxyID, PageIdentifier pageID, FrameIdentifier frameID, const String& userAgent)
    8577    : m_webPageProxyID(webPageProxyID)
     
    8880    , m_userAgent(userAgent)
    8981{
    90 }
    91 
    92 void ServiceWorkerFrameLoaderClient::frameLoaderDestroyed()
    93 {
    94     SWContextManager::singleton().removeServiceWorkerFrameLoaderClient(*this);
    9582}
    9683
     
    163150        effectiveUserAgent = m_userAgent;
    164151
    165     pageConfiguration.loaderClientForMainFrame = &ServiceWorkerFrameLoaderClient::create(m_webPageProxyID, m_pageID, FrameIdentifier::generate(), effectiveUserAgent);
     152    pageConfiguration.loaderClientForMainFrame = makeUniqueRef<ServiceWorkerFrameLoaderClient>(m_webPageProxyID, m_pageID, FrameIdentifier::generate(), effectiveUserAgent);
    166153
    167154    auto serviceWorkerThreadProxy = ServiceWorkerThreadProxy::create(WTFMove(pageConfiguration), data, WTFMove(effectiveUserAgent), WebProcess::singleton().cacheStorageProvider(), m_storageBlockingPolicy);
  • trunk/Source/WebKit/WebProcess/Storage/WebSWContextManagerConnection.h

    r258549 r258628  
    118118class ServiceWorkerFrameLoaderClient final : public WebCore::EmptyFrameLoaderClient {
    119119public:
    120     static ServiceWorkerFrameLoaderClient& create(WebPageProxyIdentifier, WebCore::PageIdentifier, WebCore::FrameIdentifier, const String& userAgent);
     120    ServiceWorkerFrameLoaderClient(WebPageProxyIdentifier, WebCore::PageIdentifier, WebCore::FrameIdentifier, const String& userAgent);
    121121
    122122    WebPageProxyIdentifier webPageProxyID() const { return m_webPageProxyID; }
     
    125125
    126126private:
    127     ServiceWorkerFrameLoaderClient(WebPageProxyIdentifier, WebCore::PageIdentifier, WebCore::FrameIdentifier, const String& userAgent);
    128 
    129127    Ref<WebCore::DocumentLoader> createDocumentLoader(const WebCore::ResourceRequest&, const WebCore::SubstituteData&) final;
    130 
    131     void frameLoaderDestroyed() final;
    132128
    133129    Optional<WebCore::PageIdentifier> pageID() const final { return m_pageID; }
     
    137133    bool isServiceWorkerFrameLoaderClient() const final { return true; }
    138134
    139     String userAgent(const URL&) final { return m_userAgent; }
     135    String userAgent(const URL&) const final { return m_userAgent; }
    140136
    141137    WebPageProxyIdentifier m_webPageProxyID;
  • trunk/Source/WebKit/WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp

    r258549 r258628  
    9797
    9898#define PREFIX_PARAMETERS "%p - [webFrame=%p, webFrameID=%" PRIu64 ", webPage=%p, webPageID=%" PRIu64 "] WebFrameLoaderClient::"
    99 #define WEBFRAME (webFrame())
    100 #define WEBFRAMEID (WEBFRAME ? WEBFRAME->frameID().toUInt64() : 0)
    101 #define WEBPAGE (WEBFRAME ? WEBFRAME->page() : nullptr)
     99#define WEBFRAME (&webFrame())
     100#define WEBFRAMEID (webFrame().frameID().toUInt64())
     101#define WEBPAGE (webFrame().page())
    102102#define WEBPAGEID (WEBPAGE ? WEBPAGE->identifier().toUInt64() : 0)
    103103
     
    109109using namespace WebCore;
    110110
    111 WebFrameLoaderClient::WebFrameLoaderClient()
    112     : m_frame(0)
    113     , m_hasSentResponseToPluginView(false)
    114     , m_didCompletePageTransition(false)
    115     , m_frameHasCustomContentProvider(false)
    116     , m_frameCameFromBackForwardCache(false)
     111WebFrameLoaderClient::WebFrameLoaderClient(Ref<WebFrame>&& frame)
     112    : m_frame(WTFMove(frame))
    117113{
    118114}
     
    120116WebFrameLoaderClient::~WebFrameLoaderClient()
    121117{
     118    m_frame->invalidate();
    122119}
    123120
    124121Optional<WebPageProxyIdentifier> WebFrameLoaderClient::webPageProxyID() const
    125122{
    126     if (m_frame && m_frame->page())
     123    if (m_frame->page())
    127124        return m_frame->page()->webPageProxyIdentifier();
    128125
     
    132129Optional<PageIdentifier> WebFrameLoaderClient::pageID() const
    133130{
    134     if (m_frame && m_frame->page())
     131    if (m_frame->page())
    135132        return m_frame->page()->identifier();
    136133
     
    140137Optional<FrameIdentifier> WebFrameLoaderClient::frameID() const
    141138{
    142     if (m_frame)
    143         return m_frame->frameID();
    144 
    145     return WTF::nullopt;
     139    return m_frame->frameID();
    146140}
    147141
     
    164158
    165159#endif
    166 
    167 void WebFrameLoaderClient::frameLoaderDestroyed()
    168 {
    169     m_frame->invalidate();
    170 
    171     // Balances explicit ref() in WebFrame::create().
    172     m_frame->deref();
    173 }
    174160
    175161bool WebFrameLoaderClient::hasHTMLView() const
     
    215201
    216202    // Notify the bundle client.
    217     webPage->injectedBundleLoaderClient().didRemoveFrameFromHierarchy(*webPage, *m_frame, userData);
     203    webPage->injectedBundleLoaderClient().didRemoveFrameFromHierarchy(*webPage, m_frame, userData);
    218204}
    219205
     
    233219        pageIsProvisionallyLoading = frameLoader->provisionalDocumentLoader() == loader;
    234220
    235     webPage->injectedBundleResourceLoadClient().didInitiateLoadForResource(*webPage, *m_frame, identifier, request, pageIsProvisionallyLoading);
     221    webPage->injectedBundleResourceLoadClient().didInitiateLoadForResource(*webPage, m_frame, identifier, request, pageIsProvisionallyLoading);
    236222    webPage->addResourceRequest(identifier, request);
    237223}
     
    246232    // is kept, so that if this is a main resource load it's still considered as such.
    247233    auto requester = request.requester();
    248     webPage->injectedBundleResourceLoadClient().willSendRequestForFrame(*webPage, *m_frame, identifier, request, redirectResponse);
     234    webPage->injectedBundleResourceLoadClient().willSendRequestForFrame(*webPage, m_frame, identifier, request, redirectResponse);
    249235    if (!request.isNull())
    250236        request.setRequester(requester);
     
    257243        return true;
    258244
    259     return webPage->injectedBundleResourceLoadClient().shouldUseCredentialStorage(*webPage, *m_frame, identifier);
     245    return webPage->injectedBundleResourceLoadClient().shouldUseCredentialStorage(*webPage, m_frame, identifier);
    260246}
    261247
     
    280266        return;
    281267
    282     webPage->injectedBundleResourceLoadClient().didReceiveResponseForResource(*webPage, *m_frame, identifier, response);
     268    webPage->injectedBundleResourceLoadClient().didReceiveResponseForResource(*webPage, m_frame, identifier, response);
    283269}
    284270
     
    289275        return;
    290276
    291     webPage->injectedBundleResourceLoadClient().didReceiveContentLengthForResource(*webPage, *m_frame, identifier, dataLength);
     277    webPage->injectedBundleResourceLoadClient().didReceiveContentLengthForResource(*webPage, m_frame, identifier, dataLength);
    292278}
    293279
     
    308294        return;
    309295
    310     webPage->injectedBundleResourceLoadClient().didFinishLoadForResource(*webPage, *m_frame, identifier);
     296    webPage->injectedBundleResourceLoadClient().didFinishLoadForResource(*webPage, m_frame, identifier);
    311297    webPage->removeResourceRequest(identifier);
    312298}
     
    318304        return;
    319305
    320     webPage->injectedBundleResourceLoadClient().didFailLoadForResource(*webPage, *m_frame, identifier, error);
     306    webPage->injectedBundleResourceLoadClient().didFailLoadForResource(*webPage, m_frame, identifier, error);
    321307    webPage->removeResourceRequest(identifier);
    322308}
     
    335321
    336322    // Notify the bundle client.
    337     webPage->injectedBundleLoaderClient().didHandleOnloadEventsForFrame(*webPage, *m_frame);
     323    webPage->injectedBundleLoaderClient().didHandleOnloadEventsForFrame(*webPage, m_frame);
    338324}
    339325
     
    355341
    356342    // Notify the bundle client.
    357     webPage->injectedBundleLoaderClient().didReceiveServerRedirectForProvisionalLoadForFrame(*webPage, *m_frame, userData);
     343    webPage->injectedBundleLoaderClient().didReceiveServerRedirectForProvisionalLoadForFrame(*webPage, m_frame, userData);
    358344
    359345    // Notify the UIProcess.
     
    378364
    379365    // Notify the bundle client.
    380     webPage->injectedBundleLoaderClient().didCancelClientRedirectForFrame(*webPage, *m_frame);
     366    webPage->injectedBundleLoaderClient().didCancelClientRedirectForFrame(*webPage, m_frame);
    381367
    382368    // Notify the UIProcess.
     
    391377
    392378    // Notify the bundle client.
    393     webPage->injectedBundleLoaderClient().willPerformClientRedirectForFrame(*webPage, *m_frame, url, interval, fireDate);
     379    webPage->injectedBundleLoaderClient().willPerformClientRedirectForFrame(*webPage, m_frame, url, interval, fireDate);
    394380
    395381    // Notify the UIProcess.
     
    408394
    409395    // Notify the bundle client.
    410     webPage->injectedBundleLoaderClient().didSameDocumentNavigationForFrame(*webPage, *m_frame, SameDocumentNavigationAnchorNavigation, userData);
     396    webPage->injectedBundleLoaderClient().didSameDocumentNavigationForFrame(*webPage, m_frame, SameDocumentNavigationAnchorNavigation, userData);
    411397
    412398    // Notify the UIProcess.
     
    452438
    453439    // Notify the bundle client.
    454     webPage->injectedBundleLoaderClient().didSameDocumentNavigationForFrame(*webPage, *m_frame, SameDocumentNavigationSessionStatePush, userData);
     440    webPage->injectedBundleLoaderClient().didSameDocumentNavigationForFrame(*webPage, m_frame, SameDocumentNavigationSessionStatePush, userData);
    455441
    456442    // Notify the UIProcess.
     
    469455
    470456    // Notify the bundle client.
    471     webPage->injectedBundleLoaderClient().didSameDocumentNavigationForFrame(*webPage, *m_frame, SameDocumentNavigationSessionStateReplace, userData);
     457    webPage->injectedBundleLoaderClient().didSameDocumentNavigationForFrame(*webPage, m_frame, SameDocumentNavigationSessionStateReplace, userData);
    472458
    473459    // Notify the UIProcess.
     
    486472
    487473    // Notify the bundle client.
    488     webPage->injectedBundleLoaderClient().didSameDocumentNavigationForFrame(*webPage, *m_frame, SameDocumentNavigationSessionStatePop, userData);
     474    webPage->injectedBundleLoaderClient().didSameDocumentNavigationForFrame(*webPage, m_frame, SameDocumentNavigationSessionStatePop, userData);
    489475
    490476    // Notify the UIProcess.
     
    520506
    521507    webPage->findController().hideFindUI();
    522     webPage->sandboxExtensionTracker().didStartProvisionalLoad(m_frame);
     508    webPage->sandboxExtensionTracker().didStartProvisionalLoad(m_frame.ptr());
    523509
    524510    WebDocumentLoader& provisionalLoader = static_cast<WebDocumentLoader&>(*m_frame->coreFrame()->loader().provisionalDocumentLoader());
     
    527513
    528514    // Notify the bundle client.
    529     webPage->injectedBundleLoaderClient().didStartProvisionalLoadForFrame(*webPage, *m_frame, userData);
     515    webPage->injectedBundleLoaderClient().didStartProvisionalLoadForFrame(*webPage, m_frame, userData);
    530516
    531517    auto& unreachableURL = provisionalLoader.unreachableURL();
     
    549535    // Notify the bundle client.
    550536    // FIXME: Use direction of title.
    551     webPage->injectedBundleLoaderClient().didReceiveTitleForFrame(*webPage, truncatedTitle.string, *m_frame, userData);
     537    webPage->injectedBundleLoaderClient().didReceiveTitleForFrame(*webPage, truncatedTitle.string, m_frame, userData);
    552538
    553539    // Notify the UIProcess.
     
    565551
    566552    // Notify the bundle client.
    567     webPage->injectedBundleLoaderClient().didCommitLoadForFrame(*webPage, *m_frame, userData);
    568 
    569     webPage->sandboxExtensionTracker().didCommitProvisionalLoad(m_frame);
     553    webPage->injectedBundleLoaderClient().didCommitLoadForFrame(*webPage, m_frame, userData);
     554
     555    webPage->sandboxExtensionTracker().didCommitProvisionalLoad(m_frame.ptr());
    570556
    571557    bool usedLegacyTLS = documentLoader.response().usedLegacyTLS();
     
    575561    // Notify the UIProcess.
    576562    webPage->send(Messages::WebPageProxy::DidCommitLoadForFrame(m_frame->frameID(), m_frame->info(), documentLoader.request(), documentLoader.navigationID(), documentLoader.response().mimeType(), m_frameHasCustomContentProvider, static_cast<uint32_t>(m_frame->coreFrame()->loader().loadType()), valueOrCompute(documentLoader.response().certificateInfo(), [] { return CertificateInfo(); }), usedLegacyTLS, m_frame->coreFrame()->document()->isPluginDocument(), hasInsecureContent, UserData(WebProcess::singleton().transformObjectsToHandles(userData.get()).get())));
    577     webPage->didCommitLoad(m_frame);
     563    webPage->didCommitLoad(m_frame.ptr());
    578564}
    579565
     
    589575
    590576    // Notify the bundle client.
    591     webPage->injectedBundleLoaderClient().didFailProvisionalLoadWithErrorForFrame(*webPage, *m_frame, error, userData);
    592 
    593     webPage->sandboxExtensionTracker().didFailProvisionalLoad(m_frame);
     577    webPage->injectedBundleLoaderClient().didFailProvisionalLoadWithErrorForFrame(*webPage, m_frame, error, userData);
     578
     579    webPage->sandboxExtensionTracker().didFailProvisionalLoad(m_frame.ptr());
    594580
    595581    // FIXME: This is gross. This is necessary because if the client calls WKBundlePageStopLoading() from within the didFailProvisionalLoadWithErrorForFrame
     
    614600    // If we have a load listener, notify it.
    615601    if (WebFrame::LoadListener* loadListener = m_frame->loadListener())
    616         loadListener->didFailLoad(m_frame, error.isCancellation());
     602        loadListener->didFailLoad(m_frame.ptr(), error.isCancellation());
    617603}
    618604
     
    631617
    632618    // Notify the bundle client.
    633     webPage->injectedBundleLoaderClient().didFailLoadWithErrorForFrame(*webPage, *m_frame, error, userData);
     619    webPage->injectedBundleLoaderClient().didFailLoadWithErrorForFrame(*webPage, m_frame, error, userData);
    634620
    635621    // Notify the UIProcess.
     
    638624    // If we have a load listener, notify it.
    639625    if (WebFrame::LoadListener* loadListener = m_frame->loadListener())
    640         loadListener->didFailLoad(m_frame, error.isCancellation());
     626        loadListener->didFailLoad(m_frame.ptr(), error.isCancellation());
    641627}
    642628
     
    652638
    653639    // Notify the bundle client.
    654     webPage->injectedBundleLoaderClient().didFinishDocumentLoadForFrame(*webPage, *m_frame, userData);
     640    webPage->injectedBundleLoaderClient().didFinishDocumentLoadForFrame(*webPage, m_frame, userData);
    655641
    656642    // Notify the UIProcess.
    657643    webPage->send(Messages::WebPageProxy::DidFinishDocumentLoadForFrame(m_frame->frameID(), navigationID, UserData(WebProcess::singleton().transformObjectsToHandles(userData.get()).get())));
    658644
    659     webPage->didFinishDocumentLoad(*m_frame);
     645    webPage->didFinishDocumentLoad(m_frame);
    660646}
    661647
     
    672658
    673659    // Notify the bundle client.
    674     webPage->injectedBundleLoaderClient().didFinishLoadForFrame(*webPage, *m_frame, userData);
     660    webPage->injectedBundleLoaderClient().didFinishLoadForFrame(*webPage, m_frame, userData);
    675661
    676662    // Notify the UIProcess.
     
    679665    // If we have a load listener, notify it.
    680666    if (WebFrame::LoadListener* loadListener = m_frame->loadListener())
    681         loadListener->didFinishLoad(m_frame);
    682 
    683     webPage->didFinishLoad(*m_frame);
     667        loadListener->didFinishLoad(m_frame.ptr());
     668
     669    webPage->didFinishLoad(m_frame);
    684670}
    685671
     
    711697        // FIXME: We should consider removing the old didFirstLayout API since this is doing double duty with the
    712698        // new didLayout API.
    713         webPage->injectedBundleLoaderClient().didFirstLayoutForFrame(*webPage, *m_frame, userData);
     699        webPage->injectedBundleLoaderClient().didFirstLayoutForFrame(*webPage, m_frame, userData);
    714700        webPage->send(Messages::WebPageProxy::DidFirstLayoutForFrame(m_frame->frameID(), UserData(WebProcess::singleton().transformObjectsToHandles(userData.get()).get())));
    715701
    716702#if USE(COORDINATED_GRAPHICS)
    717703        // Make sure viewport properties are dispatched on the main frame by the time the first layout happens.
    718         ASSERT(!webPage->useFixedLayout() || m_frame != m_frame->page()->mainWebFrame() || m_frame->coreFrame()->document()->didDispatchViewportPropertiesChanged());
     704        ASSERT(!webPage->useFixedLayout() || m_frame.ptr() != m_frame->page()->mainWebFrame() || m_frame->coreFrame()->document()->didDispatchViewportPropertiesChanged());
    719705#endif
    720706    }
     
    750736        // FIXME: We should consider removing the old didFirstVisuallyNonEmptyLayoutForFrame API since this is doing double duty with the new didLayout API.
    751737        WEBFRAMELOADERCLIENT_RELEASE_LOG(Layout, "dispatchDidReachLayoutMilestone: dispatching DidFirstVisuallyNonEmptyLayoutForFrame");
    752         webPage->injectedBundleLoaderClient().didFirstVisuallyNonEmptyLayoutForFrame(*webPage, *m_frame, userData);
     738        webPage->injectedBundleLoaderClient().didFirstVisuallyNonEmptyLayoutForFrame(*webPage, m_frame, userData);
    753739        webPage->send(Messages::WebPageProxy::DidFirstVisuallyNonEmptyLayoutForFrame(m_frame->frameID(), UserData(WebProcess::singleton().transformObjectsToHandles(userData.get()).get())));
    754740    }
     
    770756
    771757    // Notify the bundle client.
    772     webPage->injectedBundleLoaderClient().didLayoutForFrame(*webPage, *m_frame);
     758    webPage->injectedBundleLoaderClient().didLayoutForFrame(*webPage, m_frame);
    773759
    774760    webPage->recomputeShortCircuitHorizontalWheelEventsState();
     
    781767    // the UIProcess for every call.
    782768
    783     if (m_frame == m_frame->page()->mainWebFrame()) {
     769    if (m_frame.ptr() == m_frame->page()->mainWebFrame()) {
    784770        // FIXME: Remove at the soonest possible time.
    785771        webPage->send(Messages::WebPageProxy::SetRenderTreeSize(webPage->renderTreeSize()));
     
    804790void WebFrameLoaderClient::dispatchShow()
    805791{
    806     WebPage* webPage = m_frame->page();
     792    auto* webPage = m_frame->page();
    807793    if (!webPage)
    808794        return;
     
    813799void WebFrameLoaderClient::dispatchDecidePolicyForResponse(const ResourceResponse& response, const ResourceRequest& request, WebCore::PolicyCheckIdentifier identifier, const String& downloadAttribute, FramePolicyFunction&& function)
    814800{
    815     WebPage* webPage = m_frame ? m_frame->page() : nullptr;
     801    auto* webPage = m_frame->page();
    816802    if (!webPage) {
    817803        WEBFRAMELOADERCLIENT_RELEASE_LOG(Network, "dispatchDecidePolicyForResponse: ignoring because there's no web page");
     
    829815
    830816    // Notify the bundle client.
    831     WKBundlePagePolicyAction policy = webPage->injectedBundlePolicyClient().decidePolicyForResponse(webPage, m_frame, response, request, userData);
     817    WKBundlePagePolicyAction policy = webPage->injectedBundlePolicyClient().decidePolicyForResponse(webPage, m_frame.ptr(), response, request, userData);
    832818    if (policy == WKBundlePagePolicyActionUse) {
    833819        WEBFRAMELOADERCLIENT_RELEASE_LOG(Network, "dispatchDecidePolicyForResponse: continuing because injected bundle says so");
     
    838824    bool canShowResponse = webPage->canShowResponse(response);
    839825
    840     WebCore::Frame* coreFrame = m_frame->coreFrame();
     826    auto* coreFrame = m_frame->coreFrame();
    841827    auto* policyDocumentLoader = coreFrame ? coreFrame->loader().provisionalDocumentLoader() : nullptr;
    842828    auto navigationID = policyDocumentLoader ? static_cast<WebDocumentLoader&>(*policyDocumentLoader).navigationID() : 0;
    843    
    844     Ref<WebFrame> protector(*m_frame);
     829
     830    auto protector = m_frame.copyRef();
    845831    uint64_t listenerID = m_frame->setUpPolicyListener(identifier, WTFMove(function), WebFrame::ForNavigationAction::No);
    846832    if (!webPage->send(Messages::WebPageProxy::DecidePolicyForResponse(m_frame->frameID(), m_frame->info(), identifier, navigationID, response, request, canShowResponse, downloadAttribute, listenerID, UserData(WebProcess::singleton().transformObjectsToHandles(userData.get()).get())))) {
     
    853839    FormState* formState, const String& frameName, WebCore::PolicyCheckIdentifier identifier, FramePolicyFunction&& function)
    854840{
    855     WebPage* webPage = m_frame ? m_frame->page() : nullptr;
     841    auto* webPage = m_frame->page();
    856842    if (!webPage) {
    857843        function(PolicyAction::Ignore, identifier);
     
    861847    RefPtr<API::Object> userData;
    862848
    863     auto action = InjectedBundleNavigationAction::create(m_frame, navigationAction, formState);
    864 
    865     // Notify the bundle client.
    866     WKBundlePagePolicyAction policy = webPage->injectedBundlePolicyClient().decidePolicyForNewWindowAction(webPage, m_frame, action.ptr(), request, frameName, userData);
     849    auto action = InjectedBundleNavigationAction::create(m_frame.ptr(), navigationAction, formState);
     850
     851    // Notify the bundle client.
     852    WKBundlePagePolicyAction policy = webPage->injectedBundlePolicyClient().decidePolicyForNewWindowAction(webPage, m_frame.ptr(), action.ptr(), request, frameName, userData);
    867853    if (policy == WKBundlePagePolicyActionUse) {
    868854        function(PolicyAction::Use, identifier);
     
    889875void WebFrameLoaderClient::applyToDocumentLoader(WebsitePoliciesData&& websitePolicies)
    890876{
    891     if (!m_frame)
    892         return;
    893877    auto* coreFrame = m_frame->coreFrame();
    894878    if (!coreFrame)
     
    907891WebCore::AllowsContentJavaScript WebFrameLoaderClient::allowsContentJavaScriptFromMostRecentNavigation() const
    908892{
    909     WebPage* webPage = m_frame ? m_frame->page() : nullptr;
     893    auto* webPage = m_frame->page();
    910894    return webPage ? webPage->allowsContentJavaScriptFromMostRecentNavigation() : WebCore::AllowsContentJavaScript::No;
    911895}
     
    914898    FormState* formState, PolicyDecisionMode policyDecisionMode, WebCore::PolicyCheckIdentifier requestIdentifier, FramePolicyFunction&& function)
    915899{
    916     WebPage* webPage = m_frame ? m_frame->page() : nullptr;
     900    auto* webPage = m_frame->page();
    917901    if (!webPage) {
    918902        function(PolicyAction::Ignore, requestIdentifier);
     
    930914    RefPtr<API::Object> userData;
    931915
    932     Ref<InjectedBundleNavigationAction> action = InjectedBundleNavigationAction::create(m_frame, navigationAction, formState);
    933 
    934     // Notify the bundle client.
    935     WKBundlePagePolicyAction policy = webPage->injectedBundlePolicyClient().decidePolicyForNavigationAction(webPage, m_frame, action.ptr(), request, userData);
     916    Ref<InjectedBundleNavigationAction> action = InjectedBundleNavigationAction::create(m_frame.ptr(), navigationAction, formState);
     917
     918    // Notify the bundle client.
     919    WKBundlePagePolicyAction policy = webPage->injectedBundlePolicyClient().decidePolicyForNavigationAction(webPage, m_frame.ptr(), action.ptr(), request, userData);
    936920    if (policy == WKBundlePagePolicyActionUse) {
    937921        function(PolicyAction::Use, requestIdentifier);
     
    989973    navigationActionData.adClickAttribution = navigationAction.adClickAttribution();
    990974
    991     WebCore::Frame* coreFrame = m_frame->coreFrame();
     975    auto* coreFrame = m_frame->coreFrame();
    992976    if (!coreFrame)
    993977        return function(PolicyAction::Ignore, requestIdentifier);
     
    1004988
    1005989    // Notify the UIProcess.
    1006     Ref<WebFrame> protect(*m_frame);
     990    auto protector = makeRef(*coreFrame);
    1007991
    1008992    if (policyDecisionMode == PolicyDecisionMode::Synchronous) {
     
    10371021
    10381022    // Notify the bundle client.
    1039     webPage->injectedBundlePolicyClient().unableToImplementPolicy(webPage, m_frame, error, userData);
     1023    webPage->injectedBundlePolicyClient().unableToImplementPolicy(webPage, m_frame.ptr(), error, userData);
    10401024
    10411025    // Notify the UIProcess.
     
    10551039    ASSERT(sourceFrame);
    10561040
    1057     webPage->injectedBundleFormClient().willSendSubmitEvent(webPage, &form, m_frame, sourceFrame, formState->textFieldValues());
     1041    webPage->injectedBundleFormClient().willSendSubmitEvent(webPage, &form, m_frame.ptr(), sourceFrame, formState->textFieldValues());
    10581042}
    10591043
     
    10781062
    10791063    RefPtr<API::Object> userData;
    1080     webPage->injectedBundleFormClient().willSubmitForm(webPage, &form, m_frame, sourceFrame, values, userData);
     1064    webPage->injectedBundleFormClient().willSubmitForm(webPage, &form, m_frame.ptr(), sourceFrame, values, userData);
    10811065
    10821066    uint64_t listenerID = m_frame->setUpWillSubmitFormListener(WTFMove(completionHandler));
     
    11251109    if (!webPage)
    11261110        return;
    1127     webPage->willReplaceMultipartContent(*m_frame);
     1111    webPage->willReplaceMultipartContent(m_frame);
    11281112}
    11291113
     
    11331117    if (!webPage)
    11341118        return;
    1135     webPage->didReplaceMultipartContent(*m_frame);
     1119    webPage->didReplaceMultipartContent(m_frame);
    11361120}
    11371121
     
    12501234    RefPtr<API::Object> userData;
    12511235
    1252     webPage->injectedBundleLoaderClient().didDisplayInsecureContentForFrame(*webPage, *m_frame, userData);
     1236    webPage->injectedBundleLoaderClient().didDisplayInsecureContentForFrame(*webPage, m_frame, userData);
    12531237
    12541238    webPage->send(Messages::WebPageProxy::DidDisplayInsecureContentForFrame(m_frame->frameID(), UserData(WebProcess::singleton().transformObjectsToHandles(userData.get()).get())));
     
    12631247    RefPtr<API::Object> userData;
    12641248
    1265     webPage->injectedBundleLoaderClient().didRunInsecureContentForFrame(*webPage, *m_frame, userData);
     1249    webPage->injectedBundleLoaderClient().didRunInsecureContentForFrame(*webPage, m_frame, userData);
    12661250
    12671251    webPage->send(Messages::WebPageProxy::DidRunInsecureContentForFrame(m_frame->frameID(), UserData(WebProcess::singleton().transformObjectsToHandles(userData.get()).get())));
     
    12761260    RefPtr<API::Object> userData;
    12771261
    1278     webPage->injectedBundleLoaderClient().didDetectXSSForFrame(*webPage, *m_frame, userData);
     1262    webPage->injectedBundleLoaderClient().didDetectXSSForFrame(*webPage, m_frame, userData);
    12791263
    12801264    webPage->send(Messages::WebPageProxy::DidDetectXSSForFrame(m_frame->frameID(), UserData(WebProcess::singleton().transformObjectsToHandles(userData.get()).get())));
    12811265}
    12821266
    1283 ResourceError WebFrameLoaderClient::cancelledError(const ResourceRequest& request)
     1267ResourceError WebFrameLoaderClient::cancelledError(const ResourceRequest& request) const
    12841268{
    12851269    return WebKit::cancelledError(request);
    12861270}
    12871271
    1288 ResourceError WebFrameLoaderClient::blockedError(const ResourceRequest& request)
     1272ResourceError WebFrameLoaderClient::blockedError(const ResourceRequest& request) const
    12891273{
    12901274    return WebKit::blockedError(request);
    12911275}
    12921276
    1293 ResourceError WebFrameLoaderClient::blockedByContentBlockerError(const ResourceRequest& request)
     1277ResourceError WebFrameLoaderClient::blockedByContentBlockerError(const ResourceRequest& request) const
    12941278{
    12951279    return WebKit::blockedByContentBlockerError(request);
    12961280}
    12971281
    1298 ResourceError WebFrameLoaderClient::cannotShowURLError(const ResourceRequest& request)
     1282ResourceError WebFrameLoaderClient::cannotShowURLError(const ResourceRequest& request) const
    12991283{
    13001284    return WebKit::cannotShowURLError(request);
    13011285}
    13021286
    1303 ResourceError WebFrameLoaderClient::interruptedForPolicyChangeError(const ResourceRequest& request)
     1287ResourceError WebFrameLoaderClient::interruptedForPolicyChangeError(const ResourceRequest& request) const
    13041288{
    13051289    return WebKit::interruptedForPolicyChangeError(request);
     
    13071291
    13081292#if ENABLE(CONTENT_FILTERING)
    1309 ResourceError WebFrameLoaderClient::blockedByContentFilterError(const ResourceRequest& request)
     1293ResourceError WebFrameLoaderClient::blockedByContentFilterError(const ResourceRequest& request) const
    13101294{
    13111295    return WebKit::blockedByContentFilterError(request);
     
    13131297#endif
    13141298
    1315 ResourceError WebFrameLoaderClient::cannotShowMIMETypeError(const ResourceResponse& response)
     1299ResourceError WebFrameLoaderClient::cannotShowMIMETypeError(const ResourceResponse& response) const
    13161300{
    13171301    return WebKit::cannotShowMIMETypeError(response);
    13181302}
    13191303
    1320 ResourceError WebFrameLoaderClient::fileDoesNotExistError(const ResourceResponse& response)
     1304ResourceError WebFrameLoaderClient::fileDoesNotExistError(const ResourceResponse& response) const
    13211305{
    13221306    return WebKit::fileDoesNotExistError(response);
    13231307}
    13241308
    1325 ResourceError WebFrameLoaderClient::pluginWillHandleLoadError(const ResourceResponse& response)
     1309ResourceError WebFrameLoaderClient::pluginWillHandleLoadError(const ResourceResponse& response) const
    13261310{
    13271311    return WebKit::pluginWillHandleLoadError(response);
    13281312}
    13291313
    1330 bool WebFrameLoaderClient::shouldFallBack(const ResourceError& error)
     1314bool WebFrameLoaderClient::shouldFallBack(const ResourceError& error) const
    13311315{
    13321316    static NeverDestroyed<const ResourceError> cancelledError(this->cancelledError(ResourceRequest()));
     
    14101394    // FIXME: This should not be necessary. WebCore should be correctly invalidating
    14111395    // the view on restores from the back/forward cache.
    1412     if (m_frame->page() && m_frame == m_frame->page()->mainWebFrame())
     1396    if (m_frame->page() && m_frame.ptr() == m_frame->page()->mainWebFrame())
    14131397        m_frame->page()->drawingArea()->setNeedsDisplay();
    14141398#endif
     
    14311415    // If we have a load listener, notify it.
    14321416    if (WebFrame::LoadListener* loadListener = m_frame->loadListener())
    1433         loadListener->didFinishLoad(m_frame);
     1417        loadListener->didFinishLoad(m_frame.ptr());
    14341418}
    14351419
     
    14591443}
    14601444
    1461 String WebFrameLoaderClient::userAgent(const URL& url)
     1445String WebFrameLoaderClient::userAgent(const URL& url) const
    14621446{
    14631447    auto* webPage = m_frame->page();
     
    16241608
    16251609#if ENABLE(NETSCAPE_PLUGIN_API)
    1626     auto plugin = m_frame->page()->createPlugin(m_frame, &pluginElement, parameters, parameters.mimeType);
     1610    auto plugin = m_frame->page()->createPlugin(m_frame.ptr(), &pluginElement, parameters, parameters.mimeType);
    16271611    if (!plugin)
    16281612        return nullptr;
     
    16451629{
    16461630    if (auto* webPage = m_frame->page())
    1647         return webPage->webGLPolicyForURL(m_frame, url);
     1631        return webPage->webGLPolicyForURL(m_frame.ptr(), url);
    16481632
    16491633    return WebGLAllowCreation;
     
    16531637{
    16541638    if (auto* webPage = m_frame->page())
    1655         return webPage->resolveWebGLPolicyForURL(m_frame, url);
     1639        return webPage->resolveWebGLPolicyForURL(m_frame.ptr(), url);
    16561640
    16571641    return WebGLAllowCreation;
     
    17221706
    17231707    if (WebPage* webPage = m_frame->page()) {
    1724         auto allowedPluginTypes = webFrame()->coreFrame()->loader().subframeLoader().allowPlugins()
     1708        auto allowedPluginTypes = webFrame().coreFrame()->loader().subframeLoader().allowPlugins()
    17251709            ? PluginData::AllPlugins : PluginData::OnlyApplicationPlugins;
    17261710        if (webPage->corePage()->pluginData().supportsMimeType(mimeType, allowedPluginTypes))
     
    17421726String WebFrameLoaderClient::overrideMediaType() const
    17431727{
    1744     if (m_frame) {
    1745         if (auto* page = m_frame->page())
    1746             return page->overriddenMediaType();
    1747     }
     1728    if (auto* page = m_frame->page())
     1729        return page->overriddenMediaType();
    17481730
    17491731    return String();
     
    17561738        return;
    17571739
    1758     webPage->injectedBundleLoaderClient().didClearWindowObjectForFrame(*webPage, *m_frame, world);
     1740    webPage->injectedBundleLoaderClient().didClearWindowObjectForFrame(*webPage, m_frame, world);
    17591741
    17601742    WebAutomationSessionProxy* automationSessionProxy = WebProcess::singleton().automationSessionProxy();
    17611743    if (automationSessionProxy && world.isNormal())
    1762         automationSessionProxy->didClearWindowObjectForFrame(*m_frame);
     1744        automationSessionProxy->didClearWindowObjectForFrame(m_frame);
    17631745}
    17641746
     
    17691751        return;
    17701752   
    1771     webPage->injectedBundleLoaderClient().globalObjectIsAvailableForFrame(*webPage, *m_frame, world);
     1753    webPage->injectedBundleLoaderClient().globalObjectIsAvailableForFrame(*webPage, m_frame, world);
    17721754}
    17731755
     
    17781760        return;
    17791761
    1780     webPage->injectedBundleLoaderClient().willInjectUserScriptForFrame(*webPage, *m_frame, world);
     1762    webPage->injectedBundleLoaderClient().willInjectUserScriptForFrame(*webPage, m_frame, world);
    17811763}
    17821764
     
    18251807        return completionHandler(response);
    18261808
    1827     return completionHandler(webPage->injectedBundleResourceLoadClient().shouldCacheResponse(*webPage, *m_frame, identifier) ? response : nil);
     1809    return completionHandler(webPage->injectedBundleResourceLoadClient().shouldCacheResponse(*webPage, m_frame, identifier) ? response : nil);
    18281810}
    18291811
     
    18691851{
    18701852    ASSERT(!hasProcessPrivilege(ProcessPrivilege::CanAccessRawCookies));
    1871     return WebFrameNetworkingContext::create(m_frame);
     1853    return WebFrameNetworkingContext::create(m_frame.ptr());
    18721854}
    18731855
  • trunk/Source/WebKit/WebProcess/WebCoreSupport/WebFrameLoaderClient.h

    r258549 r258628  
    3838class WebFrameLoaderClient final : public WebCore::FrameLoaderClient {
    3939public:
    40     WebFrameLoaderClient();
     40    explicit WebFrameLoaderClient(Ref<WebFrame>&&);
    4141    ~WebFrameLoaderClient();
    4242
    43     void setWebFrame(WebFrame* webFrame) { m_frame = webFrame; }
    44     WebFrame* webFrame() const { return m_frame; }
     43    WebFrame& webFrame() const { return m_frame.get(); }
    4544
    4645    bool frameHasCustomContentProvider() const { return m_frameHasCustomContentProvider; }
     
    6867
    6968private:
    70     void frameLoaderDestroyed() final;
    71 
    7269    bool hasHTMLView() const final;
    7370    bool hasWebView() const final;
     
    167164    void didDetectXSS(const URL&, bool didBlockEntirePage) final;
    168165
    169     WebCore::ResourceError cancelledError(const WebCore::ResourceRequest&) final;
    170     WebCore::ResourceError blockedError(const WebCore::ResourceRequest&) final;
    171     WebCore::ResourceError blockedByContentBlockerError(const WebCore::ResourceRequest&) final;
    172     WebCore::ResourceError cannotShowURLError(const WebCore::ResourceRequest&) final;
    173     WebCore::ResourceError interruptedForPolicyChangeError(const WebCore::ResourceRequest&) final;
     166    WebCore::ResourceError cancelledError(const WebCore::ResourceRequest&) const final;
     167    WebCore::ResourceError blockedError(const WebCore::ResourceRequest&) const final;
     168    WebCore::ResourceError blockedByContentBlockerError(const WebCore::ResourceRequest&) const final;
     169    WebCore::ResourceError cannotShowURLError(const WebCore::ResourceRequest&) const final;
     170    WebCore::ResourceError interruptedForPolicyChangeError(const WebCore::ResourceRequest&) const final;
    174171#if ENABLE(CONTENT_FILTERING)
    175     WebCore::ResourceError blockedByContentFilterError(const WebCore::ResourceRequest&) final;
    176 #endif
    177    
    178     WebCore::ResourceError cannotShowMIMETypeError(const WebCore::ResourceResponse&) final;
    179     WebCore::ResourceError fileDoesNotExistError(const WebCore::ResourceResponse&) final;
    180     WebCore::ResourceError pluginWillHandleLoadError(const WebCore::ResourceResponse&) final;
    181    
    182     bool shouldFallBack(const WebCore::ResourceError&) final;
     172    WebCore::ResourceError blockedByContentFilterError(const WebCore::ResourceRequest&) const final;
     173#endif
     174   
     175    WebCore::ResourceError cannotShowMIMETypeError(const WebCore::ResourceResponse&) const final;
     176    WebCore::ResourceError fileDoesNotExistError(const WebCore::ResourceResponse&) const final;
     177    WebCore::ResourceError pluginWillHandleLoadError(const WebCore::ResourceResponse&) const final;
     178   
     179    bool shouldFallBack(const WebCore::ResourceError&) const final;
    183180   
    184181    bool canHandleRequest(const WebCore::ResourceRequest&) const final;
     
    200197    void setTitle(const WebCore::StringWithDirection&, const URL&) final;
    201198   
    202     String userAgent(const URL&) final;
     199    String userAgent(const URL&) const final;
    203200
    204201    String overrideContentSecurityPolicy() const final;
     
    281278#endif
    282279
    283     WebFrame* m_frame;
     280    Ref<WebFrame> m_frame;
    284281    RefPtr<PluginView> m_pluginView;
    285     bool m_hasSentResponseToPluginView;
    286     bool m_didCompletePageTransition;
    287     bool m_frameHasCustomContentProvider;
    288     bool m_frameCameFromBackForwardCache;
     282    bool m_hasSentResponseToPluginView { false };
     283    bool m_didCompletePageTransition { false };
     284    bool m_frameHasCustomContentProvider { false };
     285    bool m_frameCameFromBackForwardCache { false };
    289286    bool m_useIconLoadingClient { false };
    290287#if ENABLE(RESOURCE_LOAD_STATISTICS)
  • trunk/Source/WebKit/WebProcess/WebPage/WebFrame.cpp

    r258549 r258628  
    103103}
    104104
    105 Ref<WebFrame> WebFrame::createWithCoreMainFrame(WebPage* page, WebCore::Frame* coreFrame)
    106 {
    107     auto frame = create(std::unique_ptr<WebFrameLoaderClient>(static_cast<WebFrameLoaderClient*>(&coreFrame->loader().client())));
    108     page->send(Messages::WebPageProxy::DidCreateMainFrame(frame->frameID()));
    109 
    110     frame->m_coreFrame = coreFrame;
    111     frame->m_coreFrame->tree().setName(String());
    112     frame->m_coreFrame->init();
    113     return frame;
     105void WebFrame::initWithCoreMainFrame(WebPage& page, Frame& coreFrame)
     106{
     107    page.send(Messages::WebPageProxy::DidCreateMainFrame(frameID()));
     108
     109    m_coreFrame = &coreFrame;
     110    m_coreFrame->tree().setName(String());
     111    m_coreFrame->init();
    114112}
    115113
    116114Ref<WebFrame> WebFrame::createSubframe(WebPage* page, const String& frameName, HTMLFrameOwnerElement* ownerElement)
    117115{
    118     auto frame = create(makeUnique<WebFrameLoaderClient>());
     116    auto frame = create();
    119117    page->send(Messages::WebPageProxy::DidCreateSubframe(frame->frameID()));
    120118
    121     auto coreFrame = Frame::create(page->corePage(), ownerElement, frame->m_frameLoaderClient.get());
     119    auto coreFrame = Frame::create(page->corePage(), ownerElement, makeUniqueRef<WebFrameLoaderClient>(frame.get()));
    122120    frame->m_coreFrame = coreFrame.ptr();
    123121
     
    132130}
    133131
    134 Ref<WebFrame> WebFrame::create(std::unique_ptr<WebFrameLoaderClient> frameLoaderClient)
    135 {
    136     auto frame = adoptRef(*new WebFrame(WTFMove(frameLoaderClient)));
    137 
    138     // Add explict ref() that will be balanced in WebFrameLoaderClient::frameLoaderDestroyed().
    139     frame->ref();
    140 
    141     return frame;
    142 }
    143 
    144 WebFrame::WebFrame(std::unique_ptr<WebFrameLoaderClient> frameLoaderClient)
    145     : m_frameLoaderClient(WTFMove(frameLoaderClient))
    146     , m_frameID(FrameIdentifier::generate())
    147 {
    148     m_frameLoaderClient->setWebFrame(this);
     132WebFrame::WebFrame()
     133    : m_frameID(FrameIdentifier::generate())
     134{
    149135    WebProcess::singleton().addWebFrame(m_frameID, this);
    150136
     
    154140}
    155141
     142WebFrameLoaderClient* WebFrame::frameLoaderClient() const
     143{
     144    return m_coreFrame ? static_cast<WebFrameLoaderClient*>(&m_coreFrame->loader().client()) : nullptr;
     145}
     146
    156147WebFrame::~WebFrame()
    157148{
     
    184175        return nullptr;
    185176
    186     return webFrameLoaderClient->webFrame();
     177    return &webFrameLoaderClient->webFrame();
    187178}
    188179
     
    269260    invalidatePolicyListener();
    270261
    271     if (forNavigationAction && m_frameLoaderClient && policyDecision.websitePoliciesData) {
     262    if (forNavigationAction && frameLoaderClient() && policyDecision.websitePoliciesData) {
    272263        ASSERT(page());
    273264        if (page())
    274265            page()->setAllowsContentJavaScriptFromMostRecentNavigation(policyDecision.websitePoliciesData->allowsContentJavaScript);
    275         m_frameLoaderClient->applyToDocumentLoader(WTFMove(*policyDecision.websitePoliciesData));
     266        frameLoaderClient()->applyToDocumentLoader(WTFMove(*policyDecision.websitePoliciesData));
    276267    }
    277268
  • trunk/Source/WebKit/WebProcess/WebPage/WebFrame.h

    r258549 r258628  
    6666class WebFrame : public API::ObjectImpl<API::Object::Type::BundleFrame> {
    6767public:
    68     static Ref<WebFrame> createWithCoreMainFrame(WebPage*, WebCore::Frame*);
     68    static Ref<WebFrame> create() { return adoptRef(*new WebFrame); }
    6969    static Ref<WebFrame> createSubframe(WebPage*, const String& frameName, WebCore::HTMLFrameOwnerElement*);
    7070    ~WebFrame();
     71
     72    void initWithCoreMainFrame(WebPage&, WebCore::Frame&);
    7173
    7274    // Called when the FrameLoaderClient (and therefore the WebCore::Frame) is being torn down.
     
    170172#endif
    171173
    172     WebFrameLoaderClient* frameLoaderClient() const { return m_frameLoaderClient.get(); }
     174    WebFrameLoaderClient* frameLoaderClient() const;
    173175
    174176private:
    175     static Ref<WebFrame> create(std::unique_ptr<WebFrameLoaderClient>);
    176     explicit WebFrame(std::unique_ptr<WebFrameLoaderClient>);
     177    WebFrame();
    177178
    178179    WebCore::Frame* m_coreFrame { nullptr };
     
    185186    DownloadID m_policyDownloadID { 0 };
    186187
    187     std::unique_ptr<WebFrameLoaderClient> m_frameLoaderClient;
    188188    LoadListener* m_loadListener { nullptr };
    189189   
  • trunk/Source/WebKit/WebProcess/WebPage/WebPage.cpp

    r258549 r258628  
    468468    m_pageGroup = WebProcess::singleton().webPageGroup(parameters.pageGroupData);
    469469
     470    auto mainFrame = WebFrame::create();
     471
    470472    PageConfiguration pageConfiguration(
    471473        WebProcess::singleton().sessionID(),
     
    477479        WebProcess::singleton().cookieJar(),
    478480        makeUniqueRef<WebProgressTrackerClient>(*this),
     481        makeUniqueRef<WebFrameLoaderClient>(mainFrame.copyRef()),
    479482        makeUniqueRef<MediaRecorderProvider>()
    480483    );
     
    492495
    493496    pageConfiguration.plugInClient = makeUnique<WebPlugInClient>(*this);
    494     pageConfiguration.loaderClientForMainFrame = new WebFrameLoaderClient;
    495497    pageConfiguration.diagnosticLoggingClient = makeUnique<WebDiagnosticLoggingClient>(*this);
    496498    pageConfiguration.performanceLoggingClient = makeUnique<WebPerformanceLoggingClient>(*this);
     
    572574    m_page->settings().setBackForwardCacheExpirationInterval(Seconds::infinity());
    573575
    574     m_mainFrame = WebFrame::createWithCoreMainFrame(this, &m_page->mainFrame());
     576    mainFrame->initWithCoreMainFrame(*this, m_page->mainFrame());
     577    m_mainFrame = WTFMove(mainFrame);
     578
    575579    m_drawingArea->updatePreferences(parameters.store);
    576580
  • trunk/Source/WebKitLegacy/mac/ChangeLog

    r258613 r258628  
     12020-03-18  youenn fablet  <youenn@apple.com>
     2
     3        FrameLoader should own its FrameLoaderClient
     4        https://bugs.webkit.org/show_bug.cgi?id=208918
     5
     6        Reviewed by Geoff Garen.
     7
     8        Update according new Frame/FrameLoader constructors and FrameLoaderClient interface.
     9
     10        * WebCoreSupport/WebFrameLoaderClient.h:
     11        (WebFrameLoaderClient::setWebFrame):
     12        * WebCoreSupport/WebFrameLoaderClient.mm:
     13        (WebFrameLoaderClient::~WebFrameLoaderClient):
     14        (WebFrameLoaderClient::cancelledError const):
     15        (WebFrameLoaderClient::blockedError const):
     16        (WebFrameLoaderClient::blockedByContentBlockerError const):
     17        (WebFrameLoaderClient::cannotShowURLError const):
     18        (WebFrameLoaderClient::interruptedForPolicyChangeError const):
     19        (WebFrameLoaderClient::blockedByContentFilterError const):
     20        (WebFrameLoaderClient::cannotShowMIMETypeError const):
     21        (WebFrameLoaderClient::fileDoesNotExistError const):
     22        (WebFrameLoaderClient::pluginWillHandleLoadError const):
     23        (WebFrameLoaderClient::shouldFallBack const):
     24        (WebFrameLoaderClient::userAgent const):
     25        * WebView/WebFrame.mm:
     26        (+[WebFrame _createFrameWithPage:frameName:frameView:ownerElement:]):
     27        (+[WebFrame _createMainFrameWithPage:frameName:frameView:]):
     28        (+[WebFrame _createMainFrameWithSimpleHTMLDocumentWithPage:frameView:style:]):
     29        * WebView/WebView.mm:
     30        (-[WebView _commonInitializationWithFrameName:groupName:]):
     31        (-[WebView initSimpleHTMLDocumentWithStyle:frame:preferences:groupName:]):
     32
    1332020-03-17  Chris Dumez  <cdumez@apple.com>
    234
  • trunk/Source/WebKitLegacy/mac/WebCoreSupport/WebFrameLoaderClient.h

    r258549 r258628  
    5555class WebFrameLoaderClient : public WebCore::FrameLoaderClient {
    5656public:
    57     WebFrameLoaderClient(WebFrame* = 0);
    58 
    59     void setWebFrame(WebFrame* webFrame) { m_webFrame = webFrame; }
     57    explicit WebFrameLoaderClient(WebFrame* = nullptr);
     58    ~WebFrameLoaderClient();
     59
     60    void setWebFrame(WebFrame& webFrame) { m_webFrame = &webFrame; }
    6061    WebFrame* webFrame() const { return m_webFrame.get(); }
    6162
    6263private:
    63     void frameLoaderDestroyed() final;
    6464    bool hasWebView() const final; // mainly for assertions
    6565
     
    161161    void didDetectXSS(const URL&, bool didBlockEntirePage) final;
    162162
    163     WebCore::ResourceError cancelledError(const WebCore::ResourceRequest&) final;
    164     WebCore::ResourceError blockedError(const WebCore::ResourceRequest&) final;
    165     WebCore::ResourceError blockedByContentBlockerError(const WebCore::ResourceRequest&) final;
    166     WebCore::ResourceError cannotShowURLError(const WebCore::ResourceRequest&) final;
    167     WebCore::ResourceError interruptedForPolicyChangeError(const WebCore::ResourceRequest&) final;
     163    WebCore::ResourceError cancelledError(const WebCore::ResourceRequest&) const final;
     164    WebCore::ResourceError blockedError(const WebCore::ResourceRequest&) const final;
     165    WebCore::ResourceError blockedByContentBlockerError(const WebCore::ResourceRequest&) const final;
     166    WebCore::ResourceError cannotShowURLError(const WebCore::ResourceRequest&) const final;
     167    WebCore::ResourceError interruptedForPolicyChangeError(const WebCore::ResourceRequest&) const final;
    168168#if ENABLE(CONTENT_FILTERING)
    169     WebCore::ResourceError blockedByContentFilterError(const WebCore::ResourceRequest&) final;
    170 #endif
    171 
    172     WebCore::ResourceError cannotShowMIMETypeError(const WebCore::ResourceResponse&) final;
    173     WebCore::ResourceError fileDoesNotExistError(const WebCore::ResourceResponse&) final;
    174     WebCore::ResourceError pluginWillHandleLoadError(const WebCore::ResourceResponse&) final;
    175 
    176     bool shouldFallBack(const WebCore::ResourceError&) final;
    177 
    178     WTF::String userAgent(const URL&) final;
     169    WebCore::ResourceError blockedByContentFilterError(const WebCore::ResourceRequest&) const final;
     170#endif
     171
     172    WebCore::ResourceError cannotShowMIMETypeError(const WebCore::ResourceResponse&) const final;
     173    WebCore::ResourceError fileDoesNotExistError(const WebCore::ResourceResponse&) const final;
     174    WebCore::ResourceError pluginWillHandleLoadError(const WebCore::ResourceResponse&) const final;
     175
     176    bool shouldFallBack(const WebCore::ResourceError&) const final;
     177
     178    WTF::String userAgent(const URL&) const final;
    179179   
    180180    void savePlatformDataToCachedFrame(WebCore::CachedFrame*) final;
  • trunk/Source/WebKitLegacy/mac/WebCoreSupport/WebFrameLoaderClient.mm

    r258549 r258628  
    218218}
    219219
    220 void WebFrameLoaderClient::frameLoaderDestroyed()
     220WebFrameLoaderClient::~WebFrameLoaderClient()
    221221{
    222222    [m_webFrame.get() _clearCoreFrame];
    223     delete this;
    224223}
    225224
     
    11341133}
    11351134
    1136 WebCore::ResourceError WebFrameLoaderClient::cancelledError(const WebCore::ResourceRequest& request)
     1135WebCore::ResourceError WebFrameLoaderClient::cancelledError(const WebCore::ResourceRequest& request) const
    11371136{
    11381137    return [NSError _webKitErrorWithDomain:NSURLErrorDomain code:NSURLErrorCancelled URL:request.url()];
    11391138}
    11401139   
    1141 WebCore::ResourceError WebFrameLoaderClient::blockedError(const WebCore::ResourceRequest& request)
     1140WebCore::ResourceError WebFrameLoaderClient::blockedError(const WebCore::ResourceRequest& request) const
    11421141{
    11431142    return [NSError _webKitErrorWithDomain:WebKitErrorDomain code:WebKitErrorCannotUseRestrictedPort URL:request.url()];
    11441143}
    11451144
    1146 WebCore::ResourceError WebFrameLoaderClient::blockedByContentBlockerError(const WebCore::ResourceRequest& request)
     1145WebCore::ResourceError WebFrameLoaderClient::blockedByContentBlockerError(const WebCore::ResourceRequest& request) const
    11471146{
    11481147    RELEASE_ASSERT_NOT_REACHED(); // Content blockers are not enabled in WebKit1.
    11491148}
    11501149
    1151 WebCore::ResourceError WebFrameLoaderClient::cannotShowURLError(const WebCore::ResourceRequest& request)
     1150WebCore::ResourceError WebFrameLoaderClient::cannotShowURLError(const WebCore::ResourceRequest& request) const
    11521151{
    11531152    return [NSError _webKitErrorWithDomain:WebKitErrorDomain code:WebKitErrorCannotShowURL URL:request.url()];
    11541153}
    11551154
    1156 WebCore::ResourceError WebFrameLoaderClient::interruptedForPolicyChangeError(const WebCore::ResourceRequest& request)
     1155WebCore::ResourceError WebFrameLoaderClient::interruptedForPolicyChangeError(const WebCore::ResourceRequest& request) const
    11571156{
    11581157    return [NSError _webKitErrorWithDomain:WebKitErrorDomain code:WebKitErrorFrameLoadInterruptedByPolicyChange URL:request.url()];
     
    11601159
    11611160#if ENABLE(CONTENT_FILTERING)
    1162 WebCore::ResourceError WebFrameLoaderClient::blockedByContentFilterError(const WebCore::ResourceRequest& request)
     1161WebCore::ResourceError WebFrameLoaderClient::blockedByContentFilterError(const WebCore::ResourceRequest& request) const
    11631162{
    11641163    return [NSError _webKitErrorWithDomain:WebKitErrorDomain code:WebKitErrorFrameLoadBlockedByContentFilter URL:request.url()];
     
    11661165#endif
    11671166
    1168 WebCore::ResourceError WebFrameLoaderClient::cannotShowMIMETypeError(const WebCore::ResourceResponse& response)
     1167WebCore::ResourceError WebFrameLoaderClient::cannotShowMIMETypeError(const WebCore::ResourceResponse& response) const
    11691168{
    11701169    return [NSError _webKitErrorWithDomain:NSURLErrorDomain code:WebKitErrorCannotShowMIMEType URL:response.url()];
    11711170}
    11721171
    1173 WebCore::ResourceError WebFrameLoaderClient::fileDoesNotExistError(const WebCore::ResourceResponse& response)
     1172WebCore::ResourceError WebFrameLoaderClient::fileDoesNotExistError(const WebCore::ResourceResponse& response) const
    11741173{
    11751174    return [NSError _webKitErrorWithDomain:NSURLErrorDomain code:NSURLErrorFileDoesNotExist URL:response.url()];   
    11761175}
    11771176
    1178 WebCore::ResourceError WebFrameLoaderClient::pluginWillHandleLoadError(const WebCore::ResourceResponse& response)
     1177WebCore::ResourceError WebFrameLoaderClient::pluginWillHandleLoadError(const WebCore::ResourceResponse& response) const
    11791178{
    11801179    NSError *error = [[NSError alloc] _initWithPluginErrorCode:WebKitErrorPlugInWillHandleLoad
     
    11861185}
    11871186
    1188 bool WebFrameLoaderClient::shouldFallBack(const WebCore::ResourceError& error)
     1187bool WebFrameLoaderClient::shouldFallBack(const WebCore::ResourceError& error) const
    11891188{
    11901189    // FIXME: Needs to check domain.
     
    15341533}
    15351534
    1536 String WebFrameLoaderClient::userAgent(const URL& url)
     1535String WebFrameLoaderClient::userAgent(const URL& url) const
    15371536{
    15381537    WebView *webView = getWebView(m_webFrame.get());
  • trunk/Source/WebKitLegacy/mac/WebView/WebFrame.mm

    r258549 r258628  
    305305
    306306    WebFrame *frame = [[self alloc] _initWithWebFrameView:frameView webView:webView];
    307     auto coreFrame = WebCore::Frame::create(page, ownerElement, new WebFrameLoaderClient(frame));
     307    auto coreFrame = WebCore::Frame::create(page, ownerElement, makeUniqueRef<WebFrameLoaderClient>(frame));
    308308    [frame release];
    309309    frame->_private->coreFrame = coreFrame.ptr();
     
    328328    WebFrame *frame = [[self alloc] _initWithWebFrameView:frameView webView:webView];
    329329    frame->_private->coreFrame = &page->mainFrame();
    330     static_cast<WebFrameLoaderClient&>(page->mainFrame().loader().client()).setWebFrame(frame);
     330    static_cast<WebFrameLoaderClient&>(page->mainFrame().loader().client()).setWebFrame(*frame);
    331331    [frame release];
    332332
     
    356356    WebFrame *frame = [[self alloc] _initWithWebFrameView:frameView webView:webView];
    357357    frame->_private->coreFrame = &page->mainFrame();
    358     static_cast<WebFrameLoaderClient&>(page->mainFrame().loader().client()).setWebFrame(frame);
     358    static_cast<WebFrameLoaderClient&>(page->mainFrame().loader().client()).setWebFrame(*frame);
    359359    [frame release];
    360360
  • trunk/Source/WebKitLegacy/mac/WebView/WebView.mm

    r258549 r258628  
    14441444        WebCore::CookieJar::create(storageProvider.copyRef()),
    14451445        makeUniqueRef<WebProgressTrackerClient>(self),
     1446        makeUniqueRef<WebFrameLoaderClient>(),
    14461447        makeUniqueRef<WebCore::MediaRecorderProvider>()
    14471448    );
     
    14661467
    14671468    pageConfiguration.alternativeTextClient = makeUnique<WebAlternativeTextClient>(self);
    1468     pageConfiguration.loaderClientForMainFrame = new WebFrameLoaderClient;
    14691469    pageConfiguration.applicationCacheStorage = &webApplicationCacheStorage();
    14701470    pageConfiguration.databaseProvider = &WebDatabaseProvider::singleton();
     
    17151715        WebCore::CookieJar::create(storageProvider.copyRef()),
    17161716        makeUniqueRef<WebProgressTrackerClient>(self),
     1717        makeUniqueRef<WebFrameLoaderClient>(),
    17171718        makeUniqueRef<WebCore::MediaRecorderProvider>()
    17181719    );
     
    17271728
    17281729    pageConfiguration.inspectorClient = new WebInspectorClient(self);
    1729     pageConfiguration.loaderClientForMainFrame = new WebFrameLoaderClient;
    17301730    pageConfiguration.applicationCacheStorage = &webApplicationCacheStorage();
    17311731    pageConfiguration.databaseProvider = &WebDatabaseProvider::singleton();
  • trunk/Source/WebKitLegacy/win/ChangeLog

    r258549 r258628  
     12020-03-18  youenn fablet  <youenn@apple.com>
     2
     3        Make sure a preflight fails if response headers are invalid
     4        https://bugs.webkit.org/show_bug.cgi?id=208924
     5
     6        Reviewed by Geoff Garen.
     7
     8        * WebCoreSupport/WebFrameLoaderClient.cpp:
     9        (WebFrameLoaderClient::cancelledError const):
     10        (WebFrameLoaderClient::blockedError const):
     11        (WebFrameLoaderClient::blockedByContentBlockerError const):
     12        (WebFrameLoaderClient::cannotShowURLError const):
     13        (WebFrameLoaderClient::interruptedForPolicyChangeError const):
     14        (WebFrameLoaderClient::cannotShowMIMETypeError const):
     15        (WebFrameLoaderClient::fileDoesNotExistError const):
     16        (WebFrameLoaderClient::pluginWillHandleLoadError const):
     17        (WebFrameLoaderClient::shouldFallBack const):
     18        (WebFrameLoaderClient::userAgent const):
     19        (WebFrameLoaderClient::frameLoaderDestroyed): Deleted.
     20        (WebFrameLoaderClient::cancelledError): Deleted.
     21        (WebFrameLoaderClient::blockedError): Deleted.
     22        (WebFrameLoaderClient::blockedByContentBlockerError): Deleted.
     23        (WebFrameLoaderClient::cannotShowURLError): Deleted.
     24        (WebFrameLoaderClient::interruptedForPolicyChangeError): Deleted.
     25        (WebFrameLoaderClient::cannotShowMIMETypeError): Deleted.
     26        (WebFrameLoaderClient::fileDoesNotExistError): Deleted.
     27        (WebFrameLoaderClient::pluginWillHandleLoadError): Deleted.
     28        (WebFrameLoaderClient::shouldFallBack): Deleted.
     29        (WebFrameLoaderClient::userAgent): Deleted.
     30        * WebCoreSupport/WebFrameLoaderClient.h:
     31        * WebFrame.cpp:
     32        (WebFrame::createSubframeWithOwnerElement):
     33
    1342020-03-17  Commit Queue  <commit-queue@webkit.org>
    235
  • trunk/Source/WebKitLegacy/win/WebCoreSupport/WebFrameLoaderClient.cpp

    r258549 r258628  
    120120}
    121121
    122 void WebFrameLoaderClient::frameLoaderDestroyed()
    123 {
    124 }
    125 
    126122Optional<WebCore::PageIdentifier> WebFrameLoaderClient::pageID() const
    127123{
     
    786782}
    787783
    788 ResourceError WebFrameLoaderClient::cancelledError(const ResourceRequest& request)
     784ResourceError WebFrameLoaderClient::cancelledError(const ResourceRequest& request) const
    789785{
    790786    // FIXME: Need ChickenCat to include CFNetwork/CFURLError.h to get these values
     
    793789}
    794790
    795 ResourceError WebFrameLoaderClient::blockedError(const ResourceRequest& request)
     791ResourceError WebFrameLoaderClient::blockedError(const ResourceRequest& request) const
    796792{
    797793    return ResourceError(String(WebKitErrorDomain), WebKitErrorCannotUseRestrictedPort, request.url(), WEB_UI_STRING("Not allowed to use restricted network port", "WebKitErrorCannotUseRestrictedPort description"));
    798794}
    799795
    800 ResourceError WebFrameLoaderClient::blockedByContentBlockerError(const ResourceRequest& request)
     796ResourceError WebFrameLoaderClient::blockedByContentBlockerError(const ResourceRequest& request) const
    801797{
    802798    RELEASE_ASSERT_NOT_REACHED(); // Content Blockers are not enabled for WK1.
    803799}
    804800
    805 ResourceError WebFrameLoaderClient::cannotShowURLError(const ResourceRequest& request)
     801ResourceError WebFrameLoaderClient::cannotShowURLError(const ResourceRequest& request) const
    806802{
    807803    return ResourceError(String(WebKitErrorDomain), WebKitErrorCannotShowURL, request.url(), WEB_UI_STRING("The URL can\xE2\x80\x99t be shown", "WebKitErrorCannotShowURL description"));
    808804}
    809805
    810 ResourceError WebFrameLoaderClient::interruptedForPolicyChangeError(const ResourceRequest& request)
     806ResourceError WebFrameLoaderClient::interruptedForPolicyChangeError(const ResourceRequest& request) const
    811807{
    812808    return ResourceError(String(WebKitErrorDomain), WebKitErrorFrameLoadInterruptedByPolicyChange, request.url(), WEB_UI_STRING("Frame load interrupted", "WebKitErrorFrameLoadInterruptedByPolicyChange description"));
    813809}
    814810
    815 ResourceError WebFrameLoaderClient::cannotShowMIMETypeError(const ResourceResponse& response)
     811ResourceError WebFrameLoaderClient::cannotShowMIMETypeError(const ResourceResponse& response) const
    816812{
    817813    return ResourceError(String(), WebKitErrorCannotShowMIMEType, response.url(), WEB_UI_STRING("Content with specified MIME type can\xE2\x80\x99t be shown", "WebKitErrorCannotShowMIMEType description"));
    818814}
    819815
    820 ResourceError WebFrameLoaderClient::fileDoesNotExistError(const ResourceResponse& response)
     816ResourceError WebFrameLoaderClient::fileDoesNotExistError(const ResourceResponse& response) const
    821817{
    822818    return ResourceError(String(WebURLErrorDomain), -1100, response.url(), String("File does not exist."));
    823819}
    824820
    825 ResourceError WebFrameLoaderClient::pluginWillHandleLoadError(const ResourceResponse& response)
     821ResourceError WebFrameLoaderClient::pluginWillHandleLoadError(const ResourceResponse& response) const
    826822{
    827823    return ResourceError(String(WebKitErrorDomain), WebKitErrorPlugInWillHandleLoad, response.url(), WEB_UI_STRING("Plug-in handled load", "WebKitErrorPlugInWillHandleLoad description"));
    828824}
    829825
    830 bool WebFrameLoaderClient::shouldFallBack(const ResourceError& error)
     826bool WebFrameLoaderClient::shouldFallBack(const ResourceError& error) const
    831827{
    832828    if (error.errorCode() == WebURLErrorCancelled && error.domain() == String(WebURLErrorDomain))
     
    980976}
    981977
    982 String WebFrameLoaderClient::userAgent(const URL& url)
     978String WebFrameLoaderClient::userAgent(const URL& url) const
    983979{
    984980    return m_webFrame->webView()->userAgentForKURL(url);
  • trunk/Source/WebKitLegacy/win/WebCoreSupport/WebFrameLoaderClient.h

    r258549 r258628  
    5959    Ref<WebCore::FrameNetworkingContext> createNetworkingContext() override;
    6060
    61     void frameLoaderDestroyed() override;
    6261    void makeRepresentation(WebCore::DocumentLoader*) override;
    6362    void forceLayoutForNonHTML() override;
     
    138137    void didDetectXSS(const URL&, bool didBlockEntirePage) override;
    139138
    140     WebCore::ResourceError cancelledError(const WebCore::ResourceRequest&) override;
    141     WebCore::ResourceError blockedError(const WebCore::ResourceRequest&) override;
    142     WebCore::ResourceError blockedByContentBlockerError(const WebCore::ResourceRequest&) override;
    143     WebCore::ResourceError cannotShowURLError(const WebCore::ResourceRequest&) override;
    144     WebCore::ResourceError interruptedForPolicyChangeError(const WebCore::ResourceRequest&) override;
    145     WebCore::ResourceError cannotShowMIMETypeError(const WebCore::ResourceResponse&) override;
    146     WebCore::ResourceError fileDoesNotExistError(const WebCore::ResourceResponse&) override;
    147     WebCore::ResourceError pluginWillHandleLoadError(const WebCore::ResourceResponse&) override;
    148 
    149     bool shouldFallBack(const WebCore::ResourceError&) override;
    150 
    151     WTF::String userAgent(const URL&) override;
     139    WebCore::ResourceError cancelledError(const WebCore::ResourceRequest&) const override;
     140    WebCore::ResourceError blockedError(const WebCore::ResourceRequest&) const override;
     141    WebCore::ResourceError blockedByContentBlockerError(const WebCore::ResourceRequest&) const override;
     142    WebCore::ResourceError cannotShowURLError(const WebCore::ResourceRequest&) const override;
     143    WebCore::ResourceError interruptedForPolicyChangeError(const WebCore::ResourceRequest&) const override;
     144    WebCore::ResourceError cannotShowMIMETypeError(const WebCore::ResourceResponse&) const override;
     145    WebCore::ResourceError fileDoesNotExistError(const WebCore::ResourceResponse&) const override;
     146    WebCore::ResourceError pluginWillHandleLoadError(const WebCore::ResourceResponse&) const override;
     147
     148    bool shouldFallBack(const WebCore::ResourceError&) const override;
     149
     150    WTF::String userAgent(const URL&) const override;
    152151
    153152    Ref<WebCore::DocumentLoader> createDocumentLoader(const WebCore::ResourceRequest&, const WebCore::SubstituteData&) override;
  • trunk/Source/WebKitLegacy/win/WebFrame.cpp

    r258549 r258628  
    10831083
    10841084    this->AddRef(); // We release this ref in frameLoaderDestroyed()
    1085     auto frame = Frame::create(page, ownerElement, new WebFrameLoaderClient(this));
     1085    auto frame = Frame::create(page, ownerElement, makeUniqueRef<WebFrameLoaderClient>(this));
    10861086    d->frame = frame.ptr();
    10871087    return frame;
  • trunk/Source/WebKitLegacy/win/WebView.cpp

    r258549 r258628  
    31173117
    31183118    auto storageProvider = PageStorageSessionProvider::create();
     3119
     3120    WebFrame* webFrame = WebFrame::createInstance();
    31193121    PageConfiguration configuration(
    31203122        PAL::SessionID::defaultSessionID(),
     
    31263128        CookieJar::create(storageProvider.copyRef()),
    31273129        makeUniqueRef<WebProgressTrackerClient>(),
     3130        makeUniqueRef<WebFrameLoaderClient>(webFrame),
    31283131        makeUniqueRef<MediaRecorderProvider>()
    31293132    );
     
    31323135    configuration.dragClient = makeUnique<WebDragClient>(this);
    31333136    configuration.inspectorClient = m_inspectorClient;
    3134     configuration.loaderClientForMainFrame = new WebFrameLoaderClient;
    31353137    configuration.applicationCacheStorage = &WebApplicationCache::storage();
    31363138    configuration.databaseProvider = &WebDatabaseProvider::singleton();
     
    31523154    }
    31533155
    3154     WebFrame* webFrame = WebFrame::createInstance();
    31553156    webFrame->initWithWebView(this, m_page);
    31563157    static_cast<WebFrameLoaderClient&>(m_page->mainFrame().loader().client()).setWebFrame(webFrame);
Note: See TracChangeset for help on using the changeset viewer.