Changeset 220760 in webkit


Ignore:
Timestamp:
Aug 15, 2017 2:15:09 PM (7 years ago)
Author:
Chris Dumez
Message:

Update CachedResourceLoader::requestResource() to return a WTF::Expected
​https://bugs.webkit.org/show_bug.cgi?id=175505

Reviewed by Youenn Fablet.

Update CachedResourceLoader::requestResource() to return a WTF::Expected
type instead of using an out parameter for the ResourceError in case of
synchronous failure.

  • Modules/beacon/NavigatorBeacon.cpp:

(WebCore::NavigatorBeacon::sendBeacon):

  • bindings/js/CachedScriptFetcher.cpp:

(WebCore::CachedScriptFetcher::requestScriptWithCache const):

  • css/CSSFontFaceSrcValue.cpp:

(WebCore::CSSFontFaceSrcValue::cachedFont):

  • css/CSSImageSetValue.cpp:

(WebCore::CSSImageSetValue::loadBestFitImage):

  • css/CSSImageValue.cpp:

(WebCore::CSSImageValue::loadImage):

  • css/StyleRuleImport.cpp:

(WebCore::StyleRuleImport::requestStyleSheet):

  • dom/ProcessingInstruction.cpp:

(WebCore::ProcessingInstruction::checkStyleSheet):

  • html/HTMLLinkElement.cpp:

(WebCore::HTMLLinkElement::process):

  • loader/CrossOriginPreflightChecker.cpp:

(WebCore::CrossOriginPreflightChecker::startPreflight):

  • loader/DocumentLoader.cpp:

(WebCore::DocumentLoader::startLoadingMainResource):

  • loader/DocumentThreadableLoader.cpp:

(WebCore::DocumentThreadableLoader::loadRequest):

  • loader/FrameLoader.cpp:

(WebCore::FrameLoader::loadedResourceFromMemoryCache):

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

(WebCore::ImageLoader::updateFromElement):

  • loader/LinkLoader.cpp:

(WebCore::LinkLoader::preloadIfNeeded):

  • loader/MediaResourceLoader.cpp:

(WebCore::MediaResourceLoader::requestResource):

  • loader/TextTrackLoader.cpp:

(WebCore::TextTrackLoader::load):

  • loader/cache/CachedResourceLoader.cpp:

(WebCore::castCachedResourceTo):
(WebCore::CachedResourceLoader::requestImage):
(WebCore::CachedResourceLoader::requestFont):
(WebCore::CachedResourceLoader::requestTextTrack):
(WebCore::CachedResourceLoader::requestCSSStyleSheet):
(WebCore::CachedResourceLoader::requestUserCSSStyleSheet):
(WebCore::CachedResourceLoader::requestScript):
(WebCore::CachedResourceLoader::requestXSLStyleSheet):
(WebCore::CachedResourceLoader::requestSVGDocument):
(WebCore::CachedResourceLoader::requestLinkResource):
(WebCore::CachedResourceLoader::requestMedia):
(WebCore::CachedResourceLoader::requestIcon):
(WebCore::CachedResourceLoader::requestRawResource):
(WebCore::CachedResourceLoader::requestBeaconResource):
(WebCore::CachedResourceLoader::requestMainResource):
(WebCore::CachedResourceLoader::shouldContinueAfterNotifyingLoadedFromMemoryCache):
(WebCore::CachedResourceLoader::requestResource):
(WebCore::CachedResourceLoader::preload):

  • loader/cache/CachedResourceLoader.h:
  • loader/cache/CachedSVGDocumentReference.cpp:

(WebCore::CachedSVGDocumentReference::load):

  • loader/icon/IconLoader.cpp:

(WebCore::IconLoader::startLoading):

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

(WebCore::WebCoreAVFResourceLoader::startLoading):

  • svg/SVGFEImageElement.cpp:

(WebCore::SVGFEImageElement::requestImageResource):

  • svg/SVGFontFaceUriElement.cpp:

(WebCore::SVGFontFaceUriElement::loadFont):

  • svg/SVGUseElement.cpp:

(WebCore::SVGUseElement::updateExternalDocument):

  • xml/XSLImportRule.cpp:

(WebCore::XSLImportRule::loadSheet):

Location:
trunk/Source/WebCore
Files:
28 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r220759 r220760  
     12017-08-15  Chris Dumez  <cdumez@apple.com>
     2
     3        Update CachedResourceLoader::requestResource() to return a WTF::Expected
     4        https://bugs.webkit.org/show_bug.cgi?id=175505
     5
     6        Reviewed by Youenn Fablet.
     7
     8        Update CachedResourceLoader::requestResource() to return a WTF::Expected
     9        type instead of using an out parameter for the ResourceError in case of
     10        synchronous failure.
     11
     12        * Modules/beacon/NavigatorBeacon.cpp:
     13        (WebCore::NavigatorBeacon::sendBeacon):
     14        * bindings/js/CachedScriptFetcher.cpp:
     15        (WebCore::CachedScriptFetcher::requestScriptWithCache const):
     16        * css/CSSFontFaceSrcValue.cpp:
     17        (WebCore::CSSFontFaceSrcValue::cachedFont):
     18        * css/CSSImageSetValue.cpp:
     19        (WebCore::CSSImageSetValue::loadBestFitImage):
     20        * css/CSSImageValue.cpp:
     21        (WebCore::CSSImageValue::loadImage):
     22        * css/StyleRuleImport.cpp:
     23        (WebCore::StyleRuleImport::requestStyleSheet):
     24        * dom/ProcessingInstruction.cpp:
     25        (WebCore::ProcessingInstruction::checkStyleSheet):
     26        * html/HTMLLinkElement.cpp:
     27        (WebCore::HTMLLinkElement::process):
     28        * loader/CrossOriginPreflightChecker.cpp:
     29        (WebCore::CrossOriginPreflightChecker::startPreflight):
     30        * loader/DocumentLoader.cpp:
     31        (WebCore::DocumentLoader::startLoadingMainResource):
     32        * loader/DocumentThreadableLoader.cpp:
     33        (WebCore::DocumentThreadableLoader::loadRequest):
     34        * loader/FrameLoader.cpp:
     35        (WebCore::FrameLoader::loadedResourceFromMemoryCache):
     36        * loader/FrameLoader.h:
     37        * loader/ImageLoader.cpp:
     38        (WebCore::ImageLoader::updateFromElement):
     39        * loader/LinkLoader.cpp:
     40        (WebCore::LinkLoader::preloadIfNeeded):
     41        * loader/MediaResourceLoader.cpp:
     42        (WebCore::MediaResourceLoader::requestResource):
     43        * loader/TextTrackLoader.cpp:
     44        (WebCore::TextTrackLoader::load):
     45        * loader/cache/CachedResourceLoader.cpp:
     46        (WebCore::castCachedResourceTo):
     47        (WebCore::CachedResourceLoader::requestImage):
     48        (WebCore::CachedResourceLoader::requestFont):
     49        (WebCore::CachedResourceLoader::requestTextTrack):
     50        (WebCore::CachedResourceLoader::requestCSSStyleSheet):
     51        (WebCore::CachedResourceLoader::requestUserCSSStyleSheet):
     52        (WebCore::CachedResourceLoader::requestScript):
     53        (WebCore::CachedResourceLoader::requestXSLStyleSheet):
     54        (WebCore::CachedResourceLoader::requestSVGDocument):
     55        (WebCore::CachedResourceLoader::requestLinkResource):
     56        (WebCore::CachedResourceLoader::requestMedia):
     57        (WebCore::CachedResourceLoader::requestIcon):
     58        (WebCore::CachedResourceLoader::requestRawResource):
     59        (WebCore::CachedResourceLoader::requestBeaconResource):
     60        (WebCore::CachedResourceLoader::requestMainResource):
     61        (WebCore::CachedResourceLoader::shouldContinueAfterNotifyingLoadedFromMemoryCache):
     62        (WebCore::CachedResourceLoader::requestResource):
     63        (WebCore::CachedResourceLoader::preload):
     64        * loader/cache/CachedResourceLoader.h:
     65        * loader/cache/CachedSVGDocumentReference.cpp:
     66        (WebCore::CachedSVGDocumentReference::load):
     67        * loader/icon/IconLoader.cpp:
     68        (WebCore::IconLoader::startLoading):
     69        * platform/graphics/avfoundation/objc/WebCoreAVFResourceLoader.mm:
     70        (WebCore::WebCoreAVFResourceLoader::startLoading):
     71        * svg/SVGFEImageElement.cpp:
     72        (WebCore::SVGFEImageElement::requestImageResource):
     73        * svg/SVGFontFaceUriElement.cpp:
     74        (WebCore::SVGFontFaceUriElement::loadFont):
     75        * svg/SVGUseElement.cpp:
     76        (WebCore::SVGUseElement::updateExternalDocument):
     77        * xml/XSLImportRule.cpp:
     78        (WebCore::XSLImportRule::loadSheet):
     79
    1802017-08-15  Don Olmstead  <don.olmstead@sony.com>
    281

  • trunk/Source/WebCore/Modules/beacon/NavigatorBeacon.cpp

    r220751 r220760  
    7474        }
    7575    }
    76     ResourceError error;
    77     if (!document.cachedResourceLoader().requestBeaconResource({ WTFMove(request), options }, &error)) {
    78         if (!error.isNull())
    79             document.addConsoleMessage(MessageSource::Network, MessageLevel::Error, error.localizedDescription());
    80         return false;
    81     }
    82     return true;
     76    auto cachedResource = document.cachedResourceLoader().requestBeaconResource({ WTFMove(request), options });
     77    if (cachedResource)
     78        return true;
     79
     80    document.addConsoleMessage(MessageSource::Network, MessageLevel::Error, cachedResource.error().localizedDescription());
     81    return false;
    8382}
    8483

  • trunk/Source/WebCore/bindings/js/CachedScriptFetcher.cpp

    r217760 r220760  
    6464        request.setInitiator(m_initiatorName);
    6565
    66     return document.cachedResourceLoader().requestScript(WTFMove(request));
     66    return document.cachedResourceLoader().requestScript(WTFMove(request)).valueOr(nullptr);
    6767}
    6868

  • trunk/Source/WebCore/css/CSSFontFaceSrcValue.cpp

    r218890 r220760  
    102102    CachedResourceRequest request(ResourceRequest(document->completeURL(m_resource)), options);
    103103    request.setInitiator(cachedResourceRequestInitiators().css);
    104     m_cachedFont = document->cachedResourceLoader().requestFont(WTFMove(request), isSVG);
     104    m_cachedFont = document->cachedResourceLoader().requestFont(WTFMove(request), isSVG).valueOr(nullptr);
    105105    return m_cachedFont.get();
    106106}

  • trunk/Source/WebCore/css/CSSImageSetValue.cpp

    r218890 r220760  
    106106            request.updateForAccessControl(*document);
    107107
    108         m_cachedImage = loader.requestImage(WTFMove(request));
     108        m_cachedImage = loader.requestImage(WTFMove(request)).valueOr(nullptr);
    109109        m_bestFitImageScaleFactor = image.scaleFactor;
    110110    }

  • trunk/Source/WebCore/css/CSSImageValue.cpp

    r219744 r220760  
    7575            request.updateForAccessControl(*loader.document());
    7676        }
    77         m_cachedImage = loader.requestImage(WTFMove(request));
     77        m_cachedImage = loader.requestImage(WTFMove(request)).valueOr(nullptr);
    7878    }
    7979    return m_cachedImage.get();

  • trunk/Source/WebCore/css/StyleRuleImport.cpp

    r210859 r220760  
    124124        m_cachedSheet = document->cachedResourceLoader().requestUserCSSStyleSheet(WTFMove(request));
    125125    } else
    126         m_cachedSheet = document->cachedResourceLoader().requestCSSStyleSheet(WTFMove(request));
     126        m_cachedSheet = document->cachedResourceLoader().requestCSSStyleSheet(WTFMove(request)).valueOr(nullptr);
    127127    if (m_cachedSheet) {
    128128        // if the import rule is issued dynamically, the sheet may be

  • trunk/Source/WebCore/dom/ProcessingInstruction.cpp

    r214378 r220760  
    163163                auto options = CachedResourceLoader::defaultCachedResourceOptions();
    164164                options.mode = FetchOptions::Mode::SameOrigin;
    165                 m_cachedSheet = document().cachedResourceLoader().requestXSLStyleSheet({ResourceRequest(document().completeURL(href)), options});
     165                m_cachedSheet = document().cachedResourceLoader().requestXSLStyleSheet({ResourceRequest(document().completeURL(href)), options}).valueOr(nullptr);
    166166            } else
    167167#endif
    … …  
    170170                CachedResourceRequest request(document().completeURL(href), CachedResourceLoader::defaultCachedResourceOptions(), std::nullopt, charset.isEmpty() ? document().charset() : WTFMove(charset));
    171171
    172                 m_cachedSheet = document().cachedResourceLoader().requestCSSStyleSheet(WTFMove(request));
     172                m_cachedSheet = document().cachedResourceLoader().requestCSSStyleSheet(WTFMove(request)).valueOr(nullptr);
    173173            }
    174174            if (m_cachedSheet)

  • trunk/Source/WebCore/html/HTMLLinkElement.cpp

    r219234 r220760  
    314314
    315315        ASSERT_WITH_SECURITY_IMPLICATION(!m_cachedSheet);
    316         m_cachedSheet = document().cachedResourceLoader().requestCSSStyleSheet(WTFMove(request));
     316        m_cachedSheet = document().cachedResourceLoader().requestCSSStyleSheet(WTFMove(request)).valueOr(nullptr);
    317317
    318318        if (m_cachedSheet)

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

    r220442 r220760  
    108108
    109109    ASSERT(!m_resource);
    110     m_resource = m_loader.document().cachedResourceLoader().requestRawResource(WTFMove(preflightRequest));
     110    m_resource = m_loader.document().cachedResourceLoader().requestRawResource(WTFMove(preflightRequest)).valueOr(nullptr);
    111111    if (m_resource)
    112112        m_resource->addClient(*this);

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

    r220052 r220760  
    14881488        mainResourceRequest.setDomainForCachePartition(origin->domainForCachePartition());
    14891489    }
    1490     m_mainResource = m_cachedResourceLoader->requestMainResource(WTFMove(mainResourceRequest));
     1490    m_mainResource = m_cachedResourceLoader->requestMainResource(WTFMove(mainResourceRequest)).valueOr(nullptr);
    14911491
    14921492#if ENABLE(CONTENT_EXTENSIONS)

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

    r220751 r220760  
    450450        }
    451451
    452         // We create an URL here as the request will be moved in requestRawResource
    453         URL requestUrl = newRequest.resourceRequest().url();
    454         ResourceError error;
    455         m_resource = m_document.cachedResourceLoader().requestRawResource(WTFMove(newRequest), &error);
     452        auto cachedResource = m_document.cachedResourceLoader().requestRawResource(WTFMove(newRequest));
     453        m_resource = cachedResource.valueOr(nullptr);
    456454        if (m_resource)
    457455            m_resource->addClient(*this);
    458         else {
    459             if (error.isNull()) {
    460                 // FIXME: Since we receive a synchronous error, this is probably due to some AccessControl checks. We should try to retrieve the actual error.
    461                 logErrorAndFail(ResourceError(String(), 0, requestUrl, String(), ResourceError::Type::AccessControl));
    462             } else
    463                 logErrorAndFail(error);
    464         }
     456        else
     457            logErrorAndFail(cachedResource.error());
    465458        return;
    466459    }

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

    r220750 r220760  
    32373237}
    32383238
    3239 void FrameLoader::loadedResourceFromMemoryCache(CachedResource* resource, ResourceRequest& newRequest)
     3239void FrameLoader::loadedResourceFromMemoryCache(CachedResource& resource, ResourceRequest& newRequest, ResourceError& error)
    32403240{
    32413241    Page* page = m_frame.page();
    … …  
    32433243        return;
    32443244
    3245     if (!resource->shouldSendResourceLoadCallbacks() || m_documentLoader->haveToldClientAboutLoad(resource->url()))
     3245    if (!resource.shouldSendResourceLoadCallbacks() || m_documentLoader->haveToldClientAboutLoad(resource.url()))
    32463246        return;
    32473247
    32483248    // Main resource delegate messages are synthesized in MainResourceLoader, so we must not send them here.
    3249     if (resource->type() == CachedResource::MainResource)
     3249    if (resource.type() == CachedResource::MainResource)
    32503250        return;
    32513251
    32523252    if (!page->areMemoryCacheClientCallsEnabled()) {
    3253         InspectorInstrumentation::didLoadResourceFromMemoryCache(*page, m_documentLoader.get(), resource);
    3254         m_documentLoader->recordMemoryCacheLoadForFutureClientNotification(resource->resourceRequest());
    3255         m_documentLoader->didTellClientAboutLoad(resource->url());
    3256         return;
    3257     }
    3258 
    3259     if (m_client.dispatchDidLoadResourceFromMemoryCache(m_documentLoader.get(), newRequest, resource->response(), resource->encodedSize())) {
    3260         InspectorInstrumentation::didLoadResourceFromMemoryCache(*page, m_documentLoader.get(), resource);
    3261         m_documentLoader->didTellClientAboutLoad(resource->url());
     3253        InspectorInstrumentation::didLoadResourceFromMemoryCache(*page, m_documentLoader.get(), &resource);
     3254        m_documentLoader->recordMemoryCacheLoadForFutureClientNotification(resource.resourceRequest());
     3255        m_documentLoader->didTellClientAboutLoad(resource.url());
     3256        return;
     3257    }
     3258
     3259    if (m_client.dispatchDidLoadResourceFromMemoryCache(m_documentLoader.get(), newRequest, resource.response(), resource.encodedSize())) {
     3260        InspectorInstrumentation::didLoadResourceFromMemoryCache(*page, m_documentLoader.get(), &resource);
     3261        m_documentLoader->didTellClientAboutLoad(resource.url());
    32623262        return;
    32633263    }
    32643264
    32653265    unsigned long identifier;
    3266     ResourceError error;
    32673266    requestFromDelegate(newRequest, identifier, error);
    32683267
    3269     ResourceResponse response = resource->response();
     3268    ResourceResponse response = resource.response();
    32703269    response.setSource(ResourceResponse::Source::MemoryCache);
    3271     notifier().sendRemainingDelegateMessages(m_documentLoader.get(), identifier, newRequest, response, 0, resource->encodedSize(), 0, error);
     3270    notifier().sendRemainingDelegateMessages(m_documentLoader.get(), identifier, newRequest, response, 0, resource.encodedSize(), 0, error);
    32723271}
    32733272

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

    r219733 r220760  
    191191    void didFirstLayout();
    192192
    193     void loadedResourceFromMemoryCache(CachedResource*, ResourceRequest& newRequest);
     193    void loadedResourceFromMemoryCache(CachedResource&, ResourceRequest& newRequest, ResourceError&);
    194194    void tellClientAboutPastMemoryCacheLoads();
    195195

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

    r219237 r220760  
    193193            document.cachedResourceLoader().setAutoLoadImages(autoLoadOtherImages);
    194194        } else
    195             newImage = document.cachedResourceLoader().requestImage(WTFMove(request));
     195            newImage = document.cachedResourceLoader().requestImage(WTFMove(request)).valueOr(nullptr);
    196196
    197197        // If we do not have an image here, it means that a cross-site

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

    r220632 r220760  
    230230
    231231    linkRequest.setAsPotentiallyCrossOrigin(crossOriginMode, document);
    232     CachedResourceHandle<CachedResource> cachedLinkResource = document.cachedResourceLoader().preload(type.value(), WTFMove(linkRequest));
     232    auto cachedLinkResource = document.cachedResourceLoader().preload(type.value(), WTFMove(linkRequest)).valueOr(nullptr);
    233233
    234234    if (cachedLinkResource && loader)
    … …  
    280280        ResourceLoaderOptions options = CachedResourceLoader::defaultCachedResourceOptions();
    281281        options.contentSecurityPolicyImposition = ContentSecurityPolicyImposition::SkipPolicyCheck;
    282         m_cachedLinkResource = document.cachedResourceLoader().requestLinkResource(type, CachedResourceRequest(ResourceRequest(document.completeURL(href)), options, priority));
     282        m_cachedLinkResource = document.cachedResourceLoader().requestLinkResource(type, CachedResourceRequest(ResourceRequest(document.completeURL(href)), options, priority)).valueOr(nullptr);
    283283        if (m_cachedLinkResource)
    284284            m_cachedLinkResource->addClient(*this);

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

    r218609 r220760  
    8383        cacheRequest.setInitiator(*m_mediaElement.get());
    8484
    85     CachedResourceHandle<CachedRawResource> resource = m_document->cachedResourceLoader().requestMedia(WTFMove(cacheRequest));
     85    auto resource = m_document->cachedResourceLoader().requestMedia(WTFMove(cacheRequest)).valueOr(nullptr);
    8686    if (!resource)
    8787        return nullptr;

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

    r218588 r220760  
    156156    cueRequest.setAsPotentiallyCrossOrigin(crossOriginMode, *document);
    157157
    158     m_resource = document->cachedResourceLoader().requestTextTrack(WTFMove(cueRequest));
     158    m_resource = document->cachedResourceLoader().requestTextTrack(WTFMove(cueRequest)).valueOr(nullptr);
    159159    if (!m_resource)
    160160        return false;

  • trunk/Source/WebCore/loader/cache/CachedResourceLoader.cpp

    r220751 r220760  
    8787static const Seconds unusedPreloadTimeout { 3_s };
    8888
     89template <typename T, typename U>
     90static inline ResourceErrorOr<CachedResourceHandle<T>> castCachedResourceTo(ResourceErrorOr<CachedResourceHandle<U>>&& cachedResource)
     91{
     92    if (cachedResource)
     93        return CachedResourceHandle<T> { static_cast<T*>(cachedResource.value().get()) };
     94    return makeUnexpected(cachedResource.error());
     95}
     96
    8997static CachedResource* createResource(CachedResource::Type type, CachedResourceRequest&& request, SessionID sessionID)
    9098{
    … …  
    182190}
    183191
    184 CachedResourceHandle<CachedImage> CachedResourceLoader::requestImage(CachedResourceRequest&& request, ResourceError* error)
     192ResourceErrorOr<CachedResourceHandle<CachedImage>> CachedResourceLoader::requestImage(CachedResourceRequest&& request)
    185193{
    186194    if (Frame* frame = this->frame()) {
    … …  
    191199            if (requestURL.isValid() && canRequest(CachedResource::ImageResource, requestURL, request, ForPreload::No))
    192200                PingLoader::loadImage(*frame, requestURL);
    193             return nullptr;
     201            return CachedResourceHandle<CachedImage> { };
    194202        }
    195203    }
    196204
    197205    auto defer = clientDefersImage(request.resourceRequest().url()) ? DeferOption::DeferredByClient : DeferOption::NoDefer;
    198     return downcast<CachedImage>(requestResource(CachedResource::ImageResource, WTFMove(request), error, ForPreload::No, defer).get());
    199 }
    200 
    201 CachedResourceHandle<CachedFont> CachedResourceLoader::requestFont(CachedResourceRequest&& request, bool isSVG, ResourceError* error)
     206    return castCachedResourceTo<CachedImage>(requestResource(CachedResource::ImageResource, WTFMove(request), ForPreload::No, defer));
     207}
     208
     209ResourceErrorOr<CachedResourceHandle<CachedFont>> CachedResourceLoader::requestFont(CachedResourceRequest&& request, bool isSVG)
    202210{
    203211#if ENABLE(SVG_FONTS)
    204212    if (isSVG)
    205         return downcast<CachedSVGFont>(requestResource(CachedResource::SVGFontResource, WTFMove(request), error).get());
     213        return castCachedResourceTo<CachedFont>(requestResource(CachedResource::SVGFontResource, WTFMove(request)));
    206214#else
    207215    UNUSED_PARAM(isSVG);
    208216#endif
    209     return downcast<CachedFont>(requestResource(CachedResource::FontResource, WTFMove(request), error).get());
     217    return castCachedResourceTo<CachedFont>(requestResource(CachedResource::FontResource, WTFMove(request)));
    210218}
    211219
    212220#if ENABLE(VIDEO_TRACK)
    213 CachedResourceHandle<CachedTextTrack> CachedResourceLoader::requestTextTrack(CachedResourceRequest&& request, ResourceError* error)
    214 {
    215     return downcast<CachedTextTrack>(requestResource(CachedResource::TextTrackResource, WTFMove(request), error).get());
    216 }
    217 #endif
    218 
    219 CachedResourceHandle<CachedCSSStyleSheet> CachedResourceLoader::requestCSSStyleSheet(CachedResourceRequest&& request, ResourceError* error)
    220 {
    221     return downcast<CachedCSSStyleSheet>(requestResource(CachedResource::CSSStyleSheet, WTFMove(request), error).get());
    222 }
    223 
    224 CachedResourceHandle<CachedCSSStyleSheet> CachedResourceLoader::requestUserCSSStyleSheet(CachedResourceRequest&& request, ResourceError*)
     221ResourceErrorOr<CachedResourceHandle<CachedTextTrack>> CachedResourceLoader::requestTextTrack(CachedResourceRequest&& request)
     222{
     223    return castCachedResourceTo<CachedTextTrack>(requestResource(CachedResource::TextTrackResource, WTFMove(request)));
     224}
     225#endif
     226
     227ResourceErrorOr<CachedResourceHandle<CachedCSSStyleSheet>> CachedResourceLoader::requestCSSStyleSheet(CachedResourceRequest&& request)
     228{
     229    return castCachedResourceTo<CachedCSSStyleSheet>(requestResource(CachedResource::CSSStyleSheet, WTFMove(request)));
     230}
     231
     232CachedResourceHandle<CachedCSSStyleSheet> CachedResourceLoader::requestUserCSSStyleSheet(CachedResourceRequest&& request)
    225233{
    226234    ASSERT(document());
    … …  
    248256}
    249257
    250 CachedResourceHandle<CachedScript> CachedResourceLoader::requestScript(CachedResourceRequest&& request, ResourceError* error)
    251 {
    252     return downcast<CachedScript>(requestResource(CachedResource::Script, WTFMove(request), error).get());
     258ResourceErrorOr<CachedResourceHandle<CachedScript>> CachedResourceLoader::requestScript(CachedResourceRequest&& request)
     259{
     260    return castCachedResourceTo<CachedScript>(requestResource(CachedResource::Script, WTFMove(request)));
    253261}
    254262
    255263#if ENABLE(XSLT)
    256 CachedResourceHandle<CachedXSLStyleSheet> CachedResourceLoader::requestXSLStyleSheet(CachedResourceRequest&& request, ResourceError* error)
    257 {
    258     return downcast<CachedXSLStyleSheet>(requestResource(CachedResource::XSLStyleSheet, WTFMove(request), error).get());
    259 }
    260 #endif
    261 
    262 CachedResourceHandle<CachedSVGDocument> CachedResourceLoader::requestSVGDocument(CachedResourceRequest&& request, ResourceError* error)
    263 {
    264     return downcast<CachedSVGDocument>(requestResource(CachedResource::SVGDocumentResource, WTFMove(request), error).get());
     264ResourceErrorOr<CachedResourceHandle<CachedXSLStyleSheet>> CachedResourceLoader::requestXSLStyleSheet(CachedResourceRequest&& request)
     265{
     266    return castCachedResourceTo<CachedXSLStyleSheet>(requestResource(CachedResource::XSLStyleSheet, WTFMove(request)));
     267}
     268#endif
     269
     270ResourceErrorOr<CachedResourceHandle<CachedSVGDocument>> CachedResourceLoader::requestSVGDocument(CachedResourceRequest&& request)
     271{
     272    return castCachedResourceTo<CachedSVGDocument>(requestResource(CachedResource::SVGDocumentResource, WTFMove(request)));
    265273}
    266274
    267275#if ENABLE(LINK_PREFETCH)
    268 CachedResourceHandle<CachedResource> CachedResourceLoader::requestLinkResource(CachedResource::Type type, CachedResourceRequest&& request, ResourceError* error)
     276ResourceErrorOr<CachedResourceHandle<CachedResource>> CachedResourceLoader::requestLinkResource(CachedResource::Type type, CachedResourceRequest&& request)
    269277{
    270278    ASSERT(frame());
    271279    ASSERT(type == CachedResource::LinkPrefetch || type == CachedResource::LinkSubresource);
    272     return requestResource(type, WTFMove(request), error);
    273 }
    274 #endif
    275 
    276 CachedResourceHandle<CachedRawResource> CachedResourceLoader::requestMedia(CachedResourceRequest&& request, ResourceError* error)
    277 {
    278     return downcast<CachedRawResource>(requestResource(CachedResource::MediaResource, WTFMove(request), error).get());
    279 }
    280 
    281 CachedResourceHandle<CachedRawResource> CachedResourceLoader::requestIcon(CachedResourceRequest&& request, ResourceError* error)
    282 {
    283     return downcast<CachedRawResource>(requestResource(CachedResource::Icon, WTFMove(request), error).get());
    284 }
    285 
    286 CachedResourceHandle<CachedRawResource> CachedResourceLoader::requestRawResource(CachedResourceRequest&& request, ResourceError* error)
    287 {
    288     return downcast<CachedRawResource>(requestResource(CachedResource::RawResource, WTFMove(request), error).get());
    289 }
    290 
    291 CachedResourceHandle<CachedResource> CachedResourceLoader::requestBeaconResource(CachedResourceRequest&& request, ResourceError* error)
    292 {
    293     return requestResource(CachedResource::Beacon, WTFMove(request), error).get();
    294 }
    295 
    296 CachedResourceHandle<CachedRawResource> CachedResourceLoader::requestMainResource(CachedResourceRequest&& request, ResourceError* error)
    297 {
    298     return downcast<CachedRawResource>(requestResource(CachedResource::MainResource, WTFMove(request), error).get());
     280    return requestResource(type, WTFMove(request));
     281}
     282#endif
     283
     284ResourceErrorOr<CachedResourceHandle<CachedRawResource>> CachedResourceLoader::requestMedia(CachedResourceRequest&& request)
     285{
     286    return castCachedResourceTo<CachedRawResource>(requestResource(CachedResource::MediaResource, WTFMove(request)));
     287}
     288
     289ResourceErrorOr<CachedResourceHandle<CachedRawResource>> CachedResourceLoader::requestIcon(CachedResourceRequest&& request)
     290{
     291    return castCachedResourceTo<CachedRawResource>(requestResource(CachedResource::Icon, WTFMove(request)));
     292}
     293
     294ResourceErrorOr<CachedResourceHandle<CachedRawResource>> CachedResourceLoader::requestRawResource(CachedResourceRequest&& request)
     295{
     296    return castCachedResourceTo<CachedRawResource>(requestResource(CachedResource::RawResource, WTFMove(request)));
     297}
     298
     299ResourceErrorOr<CachedResourceHandle<CachedResource>> CachedResourceLoader::requestBeaconResource(CachedResourceRequest&& request)
     300{
     301    return requestResource(CachedResource::Beacon, WTFMove(request));
     302}
     303
     304ResourceErrorOr<CachedResourceHandle<CachedRawResource>> CachedResourceLoader::requestMainResource(CachedResourceRequest&& request)
     305{
     306    return castCachedResourceTo<CachedRawResource>(requestResource(CachedResource::MainResource, WTFMove(request)));
    299307}
    300308
    … …  
    557565}
    558566
    559 bool CachedResourceLoader::shouldContinueAfterNotifyingLoadedFromMemoryCache(const CachedResourceRequest& request, CachedResource* resource)
    560 {
    561     if (!resource || !frame() || resource->status() != CachedResource::Cached)
     567bool CachedResourceLoader::shouldContinueAfterNotifyingLoadedFromMemoryCache(const CachedResourceRequest& request, CachedResource& resource, ResourceError& error)
     568{
     569    if (!frame() || resource.status() != CachedResource::Cached)
    562570        return true;
    563571
    564     ResourceRequest newRequest = ResourceRequest(resource->url());
     572    ResourceRequest newRequest = ResourceRequest(resource.url());
    565573    newRequest.setInitiatorIdentifier(request.resourceRequest().initiatorIdentifier());
    566574    if (request.resourceRequest().hiddenFromInspector())
    567575        newRequest.setHiddenFromInspector(true);
    568     frame()->loader().loadedResourceFromMemoryCache(resource, newRequest);
     576    frame()->loader().loadedResourceFromMemoryCache(resource, newRequest, error);
    569577
    570578    // FIXME <http://webkit.org/b/113251>: If the delegate modifies the request's
    … …  
    689697}
    690698
    691 CachedResourceHandle<CachedResource> CachedResourceLoader::requestResource(CachedResource::Type type, CachedResourceRequest&& request, ResourceError* error, ForPreload forPreload, DeferOption defer)
     699ResourceErrorOr<CachedResourceHandle<CachedResource>> CachedResourceLoader::requestResource(CachedResource::Type type, CachedResourceRequest&& request, ForPreload forPreload, DeferOption defer)
    692700{
    693701    if (Document* document = this->document())
    … …  
    700708    if (!url.isValid()) {
    701709        RELEASE_LOG_IF_ALLOWED("requestResource: URL is invalid (frame = %p)", frame());
    702         if (error)
    703             *error = { errorDomainWebKitInternal, 0, url, ASCIILiteral("URL is invalid") };
    704         return nullptr;
     710        return makeUnexpected(ResourceError { errorDomainWebKitInternal, 0, url, ASCIILiteral("URL is invalid") });
    705711    }
    706712
    … …  
    710716    if (!canRequest(type, url, request, forPreload)) {
    711717        RELEASE_LOG_IF_ALLOWED("requestResource: Not allowed to request resource (frame = %p)", frame());
    712         if (error)
    713             *error = { errorDomainWebKitInternal, 0, url, ASCIILiteral("Not allowed to request resource"), ResourceError::Type::AccessControl };
    714         return nullptr;
     718        return makeUnexpected(ResourceError { errorDomainWebKitInternal, 0, url, ASCIILiteral("Not allowed to request resource"), ResourceError::Type::AccessControl });
    715719    }
    716720
    … …  
    723727            RELEASE_LOG_IF_ALLOWED("requestResource: Resource blocked by content blocker (frame = %p)", frame());
    724728            if (type == CachedResource::Type::MainResource) {
    725                 auto resource = createResource(type, WTFMove(request), sessionID());
     729                CachedResourceHandle<CachedResource> resource = createResource(type, WTFMove(request), sessionID());
    726730                ASSERT(resource);
    727731                resource->error(CachedResource::Status::LoadError);
    728732                resource->setResourceError(ResourceError(ContentExtensions::WebKitContentBlockerDomain, 0, resourceRequest.url(), WEB_UI_STRING("The URL was blocked by a content blocker", "WebKitErrorBlockedByContentBlocker description")));
    729                 return resource;
     733                return WTFMove(resource);
    730734            }
    731             if (error)
    732                 *error = { errorDomainWebKitInternal, 0, url, ASCIILiteral("Resource blocked by content blocker"), ResourceError::Type::AccessControl };
    733             return nullptr;
     735            return makeUnexpected(ResourceError { errorDomainWebKitInternal, 0, url, ASCIILiteral("Resource blocked by content blocker"), ResourceError::Type::AccessControl });
    734736        }
    735737        if (blockedStatus.madeHTTPS
    … …  
    795797                policy = Load;
    796798        } else {
    797             if (!shouldContinueAfterNotifyingLoadedFromMemoryCache(request, resource.get()))
    798                 return nullptr;
     799            ResourceError error;
     800            if (!shouldContinueAfterNotifyingLoadedFromMemoryCache(request, *resource, error))
     801                return makeUnexpected(WTFMove(error));
    799802            logMemoryCacheResourceRequest(frame(), DiagnosticLoggingKeys::memoryCacheEntryDecisionKey(), DiagnosticLoggingKeys::usedKey());
    800803            loadTiming.setResponseEnd(MonotonicTime::now());
    … …  
    819822        break;
    820823    }
    821 
    822     if (!resource)
    823         return nullptr;
     824    ASSERT(resource);
    824825
    825826    if (forPreload == ForPreload::No && resource->loader() && resource->ignoreForRequestCount()) {
    … …  
    835836            if (resource->allowsCaching() && resource->inCache())
    836837                memoryCache.remove(*resource);
    837             if (error) {
    838                 auto resourceError = resource->resourceError();
    839                 // Synchronous cancellations are likely due to access control.
    840                 *error = !resourceError.isNull() && !resourceError.isCancellation() ? resourceError : ResourceError(String(), 0, url, String(), ResourceError::Type::AccessControl);
    841             }
    842             return nullptr;
     838
     839            auto resourceError = resource->resourceError();
     840            // Synchronous cancellations are likely due to access control.
     841            if (resourceError.isNull() || resourceError.isCancellation())
     842                return makeUnexpected(ResourceError { String(), 0, url, String(), ResourceError::Type::AccessControl });
     843            return makeUnexpected(resourceError);
    843844        }
    844845    }
    … …  
    849850    ASSERT(resource->url() == url.string());
    850851    m_documentResources.set(resource->url(), resource);
    851     return resource;
     852    return WTFMove(resource);
    852853}
    853854
    … …  
    12511252}
    12521253
    1253 CachedResourceHandle<CachedResource> CachedResourceLoader::preload(CachedResource::Type type, CachedResourceRequest&& request)
     1254ResourceErrorOr<CachedResourceHandle<CachedResource>> CachedResourceLoader::preload(CachedResource::Type type, CachedResourceRequest&& request)
    12541255{
    12551256    if (request.charset().isEmpty() && (type == CachedResource::Script || type == CachedResource::CSSStyleSheet))
    12561257        request.setCharset(m_document->charset());
    12571258
    1258     CachedResourceHandle<CachedResource> resource = requestResource(type, WTFMove(request), nullptr, ForPreload::Yes);
    1259     if (resource && (!m_preloads || !m_preloads->contains(resource.get()))) {
     1259    auto resource = requestResource(type, WTFMove(request), ForPreload::Yes);
     1260    if (resource && (!m_preloads || !m_preloads->contains(resource.value().get()))) {
     1261        auto resourceValue = resource.value();
    12601262        // Fonts need special treatment since just creating the resource doesn't trigger a load.
    12611263        if (type == CachedResource::FontResource)
    1262             downcast<CachedFont>(resource.get())->beginLoadIfNeeded(*this);
    1263         resource->increasePreloadCount();
     1264            downcast<CachedFont>(resourceValue.get())->beginLoadIfNeeded(*this);
     1265        resourceValue->increasePreloadCount();
    12641266
    12651267        if (!m_preloads)
    12661268            m_preloads = std::make_unique<ListHashSet<CachedResource*>>();
    1267         m_preloads->add(resource.get());
     1269        m_preloads->add(resourceValue.get());
    12681270    }
    12691271    return resource;

  • trunk/Source/WebCore/loader/cache/CachedResourceLoader.h

    r220751 r220760  
    3434#include "ResourceTimingInformation.h"
    3535#include "Timer.h"
     36#include <wtf/Expected.h>
    3637#include <wtf/HashMap.h>
    3738#include <wtf/HashSet.h>
    … …  
    5657class URL;
    5758
     59template <typename T>
     60using ResourceErrorOr = Expected<T, ResourceError>;
     61
    5862// The CachedResourceLoader provides a per-context interface to the MemoryCache
    5963// and enforces a bunch of security checks and rules for resource revalidation.
    … …  
    7377    ~CachedResourceLoader();
    7478
    75     CachedResourceHandle<CachedImage> requestImage(CachedResourceRequest&&, ResourceError* = nullptr);
    76     CachedResourceHandle<CachedCSSStyleSheet> requestCSSStyleSheet(CachedResourceRequest&&, ResourceError* = nullptr);
    77     CachedResourceHandle<CachedCSSStyleSheet> requestUserCSSStyleSheet(CachedResourceRequest&&, ResourceError* = nullptr);
    78     CachedResourceHandle<CachedScript> requestScript(CachedResourceRequest&&, ResourceError* = nullptr);
    79     CachedResourceHandle<CachedFont> requestFont(CachedResourceRequest&&, bool isSVG, ResourceError* = nullptr);
    80     CachedResourceHandle<CachedRawResource> requestMedia(CachedResourceRequest&&, ResourceError* = nullptr);
    81     CachedResourceHandle<CachedRawResource> requestIcon(CachedResourceRequest&&, ResourceError* = nullptr);
    82     CachedResourceHandle<CachedResource> requestBeaconResource(CachedResourceRequest&&, ResourceError* = nullptr);
    83     CachedResourceHandle<CachedRawResource> requestRawResource(CachedResourceRequest&&, ResourceError* = nullptr);
    84     CachedResourceHandle<CachedRawResource> requestMainResource(CachedResourceRequest&&, ResourceError* = nullptr);
    85     CachedResourceHandle<CachedSVGDocument> requestSVGDocument(CachedResourceRequest&&, ResourceError* = nullptr);
     79    ResourceErrorOr<CachedResourceHandle<CachedImage>> requestImage(CachedResourceRequest&&);
     80    ResourceErrorOr<CachedResourceHandle<CachedCSSStyleSheet>> requestCSSStyleSheet(CachedResourceRequest&&);
     81    CachedResourceHandle<CachedCSSStyleSheet> requestUserCSSStyleSheet(CachedResourceRequest&&);
     82    ResourceErrorOr<CachedResourceHandle<CachedScript>> requestScript(CachedResourceRequest&&);
     83    ResourceErrorOr<CachedResourceHandle<CachedFont>> requestFont(CachedResourceRequest&&, bool isSVG);
     84    ResourceErrorOr<CachedResourceHandle<CachedRawResource>> requestMedia(CachedResourceRequest&&);
     85    ResourceErrorOr<CachedResourceHandle<CachedRawResource>> requestIcon(CachedResourceRequest&&);
     86    ResourceErrorOr<CachedResourceHandle<CachedResource>> requestBeaconResource(CachedResourceRequest&&);
     87    ResourceErrorOr<CachedResourceHandle<CachedRawResource>> requestRawResource(CachedResourceRequest&&);
     88    ResourceErrorOr<CachedResourceHandle<CachedRawResource>> requestMainResource(CachedResourceRequest&&);
     89    ResourceErrorOr<CachedResourceHandle<CachedSVGDocument>> requestSVGDocument(CachedResourceRequest&&);
    8690#if ENABLE(XSLT)
    87     CachedResourceHandle<CachedXSLStyleSheet> requestXSLStyleSheet(CachedResourceRequest&&, ResourceError* = nullptr);
     91    ResourceErrorOr<CachedResourceHandle<CachedXSLStyleSheet>> requestXSLStyleSheet(CachedResourceRequest&&);
    8892#endif
    8993#if ENABLE(LINK_PREFETCH)
    90     CachedResourceHandle<CachedResource> requestLinkResource(CachedResource::Type, CachedResourceRequest&&, ResourceError* = nullptr);
     94    ResourceErrorOr<CachedResourceHandle<CachedResource>> requestLinkResource(CachedResource::Type, CachedResourceRequest&&);
    9195#endif
    9296#if ENABLE(VIDEO_TRACK)
    93     CachedResourceHandle<CachedTextTrack> requestTextTrack(CachedResourceRequest&&, ResourceError* = nullptr);
     97    ResourceErrorOr<CachedResourceHandle<CachedTextTrack>> requestTextTrack(CachedResourceRequest&&);
    9498#endif
    9599
    … …  
    133137    enum class ClearPreloadsMode { ClearSpeculativePreloads, ClearAllPreloads };
    134138    void clearPreloads(ClearPreloadsMode);
    135     CachedResourceHandle<CachedResource> preload(CachedResource::Type, CachedResourceRequest&&);
     139    ResourceErrorOr<CachedResourceHandle<CachedResource>> preload(CachedResource::Type, CachedResourceRequest&&);
    136140    void printPreloadStats();
    137141    void warnUnusedPreloads();
    … …  
    156160    enum class DeferOption { NoDefer, DeferredByClient };
    157161
    158     CachedResourceHandle<CachedResource> requestResource(CachedResource::Type, CachedResourceRequest&&, ResourceError* = nullptr, ForPreload = ForPreload::No, DeferOption = DeferOption::NoDefer);
     162    ResourceErrorOr<CachedResourceHandle<CachedResource>> requestResource(CachedResource::Type, CachedResourceRequest&&, ForPreload = ForPreload::No, DeferOption = DeferOption::NoDefer);
    159163    CachedResourceHandle<CachedResource> revalidateResource(CachedResourceRequest&&, CachedResource&);
    160164    CachedResourceHandle<CachedResource> loadResource(CachedResource::Type, CachedResourceRequest&&);
    … …  
    172176    CachedResourceHandle<CachedResource> updateCachedResourceWithCurrentRequest(const CachedResource&, CachedResourceRequest&&);
    173177
    174     bool shouldContinueAfterNotifyingLoadedFromMemoryCache(const CachedResourceRequest&, CachedResource*);
     178    bool shouldContinueAfterNotifyingLoadedFromMemoryCache(const CachedResourceRequest&, CachedResource&, ResourceError&);
    175179    bool checkInsecureContent(CachedResource::Type, const URL&) const;
    176180    bool allowedByContentSecurityPolicy(CachedResource::Type, const URL&, const ResourceLoaderOptions&, ContentSecurityPolicy::RedirectResponseReceived) const;

  • trunk/Source/WebCore/loader/cache/CachedSVGDocumentReference.cpp

    r206867 r220760  
    5757    CachedResourceRequest request(ResourceRequest(loader.document()->completeURL(m_url)), fetchOptions);
    5858    request.setInitiator(cachedResourceRequestInitiators().css);
    59     m_document = loader.requestSVGDocument(WTFMove(request));
     59    m_document = loader.requestSVGDocument(WTFMove(request)).valueOr(nullptr);
    6060    if (m_document)
    6161        m_document->addClient(*this);

  • trunk/Source/WebCore/loader/icon/IconLoader.cpp

    r219733 r220760  
    7676    request.setInitiator(cachedResourceRequestInitiators().icon);
    7777
    78     m_resource = frame->document()->cachedResourceLoader().requestIcon(WTFMove(request));
     78    auto cachedResource = frame->document()->cachedResourceLoader().requestIcon(WTFMove(request));
     79    m_resource = cachedResource.valueOr(nullptr);
    7980    if (m_resource)
    8081        m_resource->addClient(*this);
    8182    else
    82         LOG_ERROR("Failed to start load for icon at url %s", resourceRequestURL.string().ascii().data());
     83        LOG_ERROR("Failed to start load for icon at url %s (error: %s)", resourceRequestURL.string().ascii().data(), cachedResource.error().localizedDescription().utf8().data());
    8384}
    8485

  • trunk/Source/WebCore/platform/graphics/avfoundation/cf/WebCoreAVCFResourceLoader.cpp

    r219191 r220760  
    7878
    7979    CachedResourceLoader* loader = m_parent->player()->cachedResourceLoader();
    80     m_resource = loader ? loader->requestRawResource(WTFMove(request)) : 0;
     80    m_resource = loader ? loader->requestRawResource(WTFMove(request)).valueOr(nullptr) : nullptr;
    8181    if (m_resource)
    8282        m_resource->addClient(*this);

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

    r219191 r220760  
    7575    CachedResourceRequest request(WTFMove(resourceRequest), ResourceLoaderOptions(SendCallbacks, DoNotSniffContent, BufferData, DoNotAllowStoredCredentials, ClientCredentialPolicy::CannotAskClientForCredentials, FetchOptions::Credentials::Omit, DoSecurityCheck, FetchOptions::Mode::NoCors, DoNotIncludeCertificateInfo, ContentSecurityPolicyImposition::DoPolicyCheck, DefersLoadingPolicy::AllowDefersLoading, CachingPolicy::DisallowCaching));
    7676    if (auto* loader = m_parent->player()->cachedResourceLoader())
    77         m_resource = loader->requestMedia(WTFMove(request));
     77        m_resource = loader->requestMedia(WTFMove(request)).valueOr(nullptr);
    7878
    7979    if (m_resource)

  • trunk/Source/WebCore/svg/SVGFEImageElement.cpp

    r211591 r220760  
    9090    CachedResourceRequest request(ResourceRequest(document().completeURL(href())), options);
    9191    request.setInitiator(*this);
    92     m_cachedImage = document().cachedResourceLoader().requestImage(WTFMove(request));
     92    m_cachedImage = document().cachedResourceLoader().requestImage(WTFMove(request)).valueOr(nullptr);
    9393
    9494    if (m_cachedImage)

  • trunk/Source/WebCore/svg/SVGFontFaceUriElement.cpp

    r210845 r220760  
    107107        CachedResourceRequest request(ResourceRequest(document().completeURL(href)), options);
    108108        request.setInitiator(*this);
    109         m_cachedFont = cachedResourceLoader.requestFont(WTFMove(request), isSVGFontTarget(*this));
     109        m_cachedFont = cachedResourceLoader.requestFont(WTFMove(request), isSVGFontTarget(*this)).valueOr(nullptr);
    110110        if (m_cachedFont) {
    111111            m_cachedFont->addClient(*this);

  • trunk/Source/WebCore/svg/SVGUseElement.cpp

    r219237 r220760  
    575575        CachedResourceRequest request { ResourceRequest { externalDocumentURL }, options };
    576576        request.setInitiator(*this);
    577         m_externalDocument = document().cachedResourceLoader().requestSVGDocument(WTFMove(request));
     577        m_externalDocument = document().cachedResourceLoader().requestSVGDocument(WTFMove(request)).valueOr(nullptr);
    578578        if (m_externalDocument)
    579579            m_externalDocument->addClient(*this);

  • trunk/Source/WebCore/xml/XSLImportRule.cpp

    r206867 r220760  
    104104    auto options = CachedResourceLoader::defaultCachedResourceOptions();
    105105    options.mode = FetchOptions::Mode::SameOrigin;
    106     m_cachedSheet = cachedResourceLoader->requestXSLStyleSheet({ResourceRequest(cachedResourceLoader->document()->completeURL(absHref)), options});
     106    m_cachedSheet = cachedResourceLoader->requestXSLStyleSheet({ResourceRequest(cachedResourceLoader->document()->completeURL(absHref)), options}).valueOr(nullptr);
    107107
    108108    if (m_cachedSheet) {
Note: See TracChangeset for help on using the changeset viewer.