Changeset 203971 in webkit


Ignore:
Timestamp:
Aug 1, 2016 12:02:35 AM (8 years ago)
Author:
commit-queue@webkit.org
Message:

Reduce the number of ResourceRequest copies in DocumentThreadableLoader
https://bugs.webkit.org/show_bug.cgi?id=160338

Patch by Youenn Fablet <youennf@gmail.com> on 2016-08-01
Reviewed by Darin Adler.

No observable change of behavior.

Updating one of CachedResourceReques constructor to take a ResourceRequest&&.
This allows reducing a ResourceRequest copy in DocumentThreadableLoader.
Updating DocumentLoader and MediaResourceLoader accordingly (future optimization steps may look at making these
two loaders more efficient with regards to Resource Request).

Updating ThreadableLoader to take a ResourceRequest&&.
This allows reducing the number of copies in DocumentThreadableLoader.
Updating clients of ThreadableLoader accordingly.

  • Modules/fetch/FetchLoader.cpp:

(WebCore::FetchLoader::start):

  • dom/Document.cpp:

(WebCore::Document::didLoadResourceSynchronously):

  • dom/Document.h:
  • dom/ScriptExecutionContext.cpp:

(WebCore::ScriptExecutionContext::didLoadResourceSynchronously):

  • dom/ScriptExecutionContext.h:
  • fileapi/FileReaderLoader.cpp:

(WebCore::FileReaderLoader::start):

  • inspector/InspectorNetworkAgent.cpp:

(WebCore::InspectorNetworkAgent::loadResource):

  • loader/DocumentLoader.cpp:

(WebCore::DocumentLoader::startLoadingMainResource):

  • loader/DocumentThreadableLoader.cpp:

(WebCore::DocumentThreadableLoader::loadResourceSynchronously):
(WebCore::DocumentThreadableLoader::create):
(WebCore::DocumentThreadableLoader::DocumentThreadableLoader):
(WebCore::DocumentThreadableLoader::makeCrossOriginAccessRequest):
(WebCore::DocumentThreadableLoader::makeSimpleCrossOriginAccessRequest):
(WebCore::DocumentThreadableLoader::redirectReceived):
(WebCore::DocumentThreadableLoader::preflightSuccess):
(WebCore::DocumentThreadableLoader::loadRequest):

  • loader/DocumentThreadableLoader.h:
  • loader/MediaResourceLoader.cpp:

(WebCore::MediaResourceLoader::requestResource):

  • loader/ThreadableLoader.cpp:

(WebCore::ThreadableLoader::create):
(WebCore::ThreadableLoader::loadResourceSynchronously):

  • loader/ThreadableLoader.h:
  • loader/WorkerThreadableLoader.cpp:

(WebCore::WorkerThreadableLoader::WorkerThreadableLoader):
(WebCore::WorkerThreadableLoader::loadResourceSynchronously):
(WebCore::WorkerThreadableLoader::MainThreadBridge::MainThreadBridge):

  • loader/WorkerThreadableLoader.h:

(WebCore::WorkerThreadableLoader::create):

  • loader/cache/CachedResourceRequest.cpp:

(WebCore::CachedResourceRequest::CachedResourceRequest):

  • loader/cache/CachedResourceRequest.h:
  • page/EventSource.cpp:

(WebCore::EventSource::connect):

  • workers/WorkerScriptLoader.cpp:

(WebCore::WorkerScriptLoader::loadSynchronously):
(WebCore::WorkerScriptLoader::loadAsynchronously):

  • xml/XMLHttpRequest.cpp:

(WebCore::XMLHttpRequest::createRequest):

Location:
trunk/Source/WebCore
Files:
21 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r203961 r203971  
     12016-08-01  Youenn Fablet  <youennf@gmail.com>
     2
     3        Reduce the number of ResourceRequest copies in DocumentThreadableLoader
     4        https://bugs.webkit.org/show_bug.cgi?id=160338
     5
     6        Reviewed by Darin Adler.
     7
     8        No observable change of behavior.
     9
     10        Updating one of CachedResourceReques constructor to take a ResourceRequest&&.
     11        This allows reducing a ResourceRequest copy in DocumentThreadableLoader.
     12        Updating DocumentLoader and MediaResourceLoader accordingly (future optimization steps may look at making these
     13        two loaders more efficient with regards to Resource Request).
     14
     15        Updating ThreadableLoader to take a ResourceRequest&&.
     16        This allows reducing the number of copies in DocumentThreadableLoader.
     17        Updating clients of ThreadableLoader accordingly.
     18
     19        * Modules/fetch/FetchLoader.cpp:
     20        (WebCore::FetchLoader::start):
     21        * dom/Document.cpp:
     22        (WebCore::Document::didLoadResourceSynchronously):
     23        * dom/Document.h:
     24        * dom/ScriptExecutionContext.cpp:
     25        (WebCore::ScriptExecutionContext::didLoadResourceSynchronously):
     26        * dom/ScriptExecutionContext.h:
     27        * fileapi/FileReaderLoader.cpp:
     28        (WebCore::FileReaderLoader::start):
     29        * inspector/InspectorNetworkAgent.cpp:
     30        (WebCore::InspectorNetworkAgent::loadResource):
     31        * loader/DocumentLoader.cpp:
     32        (WebCore::DocumentLoader::startLoadingMainResource):
     33        * loader/DocumentThreadableLoader.cpp:
     34        (WebCore::DocumentThreadableLoader::loadResourceSynchronously):
     35        (WebCore::DocumentThreadableLoader::create):
     36        (WebCore::DocumentThreadableLoader::DocumentThreadableLoader):
     37        (WebCore::DocumentThreadableLoader::makeCrossOriginAccessRequest):
     38        (WebCore::DocumentThreadableLoader::makeSimpleCrossOriginAccessRequest):
     39        (WebCore::DocumentThreadableLoader::redirectReceived):
     40        (WebCore::DocumentThreadableLoader::preflightSuccess):
     41        (WebCore::DocumentThreadableLoader::loadRequest):
     42        * loader/DocumentThreadableLoader.h:
     43        * loader/MediaResourceLoader.cpp:
     44        (WebCore::MediaResourceLoader::requestResource):
     45        * loader/ThreadableLoader.cpp:
     46        (WebCore::ThreadableLoader::create):
     47        (WebCore::ThreadableLoader::loadResourceSynchronously):
     48        * loader/ThreadableLoader.h:
     49        * loader/WorkerThreadableLoader.cpp:
     50        (WebCore::WorkerThreadableLoader::WorkerThreadableLoader):
     51        (WebCore::WorkerThreadableLoader::loadResourceSynchronously):
     52        (WebCore::WorkerThreadableLoader::MainThreadBridge::MainThreadBridge):
     53        * loader/WorkerThreadableLoader.h:
     54        (WebCore::WorkerThreadableLoader::create):
     55        * loader/cache/CachedResourceRequest.cpp:
     56        (WebCore::CachedResourceRequest::CachedResourceRequest):
     57        * loader/cache/CachedResourceRequest.h:
     58        * page/EventSource.cpp:
     59        (WebCore::EventSource::connect):
     60        * workers/WorkerScriptLoader.cpp:
     61        (WebCore::WorkerScriptLoader::loadSynchronously):
     62        (WebCore::WorkerScriptLoader::loadAsynchronously):
     63        * xml/XMLHttpRequest.cpp:
     64        (WebCore::XMLHttpRequest::createRequest):
     65
    1662016-07-31  Youenn Fablet  <youenn@apple.com>
    267
  • trunk/Source/WebCore/Modules/fetch/FetchLoader.cpp

    r203900 r203971  
    6868    options.contentSecurityPolicyEnforcement = ContentSecurityPolicyEnforcement::DoNotEnforce;
    6969
    70     m_loader = ThreadableLoader::create(&context, this, request, options);
     70    m_loader = ThreadableLoader::create(&context, this, WTFMove(request), options);
    7171    m_isStarted = m_loader;
    7272}
  • trunk/Source/WebCore/dom/Document.cpp

    r203761 r203971  
    68756875}
    68766876
    6877 void Document::didLoadResourceSynchronously(const ResourceRequest&)
     6877void Document::didLoadResourceSynchronously()
    68786878{
    68796879    // Synchronous resources loading can set cookies so we invalidate the cookies cache
  • trunk/Source/WebCore/dom/Document.h

    r203761 r203971  
    14221422    bool isDOMCookieCacheValid() const { return m_cookieCacheExpiryTimer.isActive(); }
    14231423    void invalidateDOMCookieCache();
    1424     void didLoadResourceSynchronously(const ResourceRequest&) final;
     1424    void didLoadResourceSynchronously() final;
    14251425
    14261426    void checkViewportDependentPictures();
  • trunk/Source/WebCore/dom/ScriptExecutionContext.cpp

    r202105 r203971  
    177177}
    178178
    179 void ScriptExecutionContext::didLoadResourceSynchronously(const ResourceRequest&)
     179void ScriptExecutionContext::didLoadResourceSynchronously()
    180180{
    181181}
  • trunk/Source/WebCore/dom/ScriptExecutionContext.h

    r202930 r203971  
    133133    void destroyedMessagePort(MessagePort&);
    134134
    135     virtual void didLoadResourceSynchronously(const ResourceRequest&);
     135    virtual void didLoadResourceSynchronously();
    136136
    137137    void ref() { refScriptExecutionContext(); }
  • trunk/Source/WebCore/fileapi/FileReaderLoader.cpp

    r203900 r203971  
    9696
    9797    if (m_client)
    98         m_loader = ThreadableLoader::create(scriptExecutionContext, this, request, options);
     98        m_loader = ThreadableLoader::create(scriptExecutionContext, this, WTFMove(request), options);
    9999    else
    100         ThreadableLoader::loadResourceSynchronously(scriptExecutionContext, request, *this, options);
     100        ThreadableLoader::loadResourceSynchronously(scriptExecutionContext, WTFMove(request), *this, options);
    101101}
    102102
  • trunk/Source/WebCore/inspector/InspectorNetworkAgent.cpp

    r203900 r203971  
    680680    InspectorThreadableLoaderClient* inspectorThreadableLoaderClient = new InspectorThreadableLoaderClient(callback.copyRef());
    681681
    682     auto loader = DocumentThreadableLoader::create(*document, *inspectorThreadableLoaderClient, request, options);
     682    auto loader = DocumentThreadableLoader::create(*document, *inspectorThreadableLoaderClient, WTFMove(request), options);
    683683    if (!loader) {
    684684        inspectorThreadableLoaderClient->didFailLoaderCreation();
  • trunk/Source/WebCore/loader/DocumentLoader.cpp

    r203723 r203971  
    15121512
    15131513    static NeverDestroyed<ResourceLoaderOptions> mainResourceLoadOptions(SendCallbacks, SniffContent, BufferData, AllowStoredCredentials, ClientCredentialPolicy::MayAskClientForCredentials, FetchOptions::Credentials::Include, SkipSecurityCheck, FetchOptions::Mode::NoCors, IncludeCertificateInfo, ContentSecurityPolicyImposition::DoPolicyCheck, DefersLoadingPolicy::AllowDefersLoading, CachingPolicy::AllowCaching);
    1514     CachedResourceRequest cachedResourceRequest(request, mainResourceLoadOptions);
     1514    CachedResourceRequest cachedResourceRequest(ResourceRequest(request), mainResourceLoadOptions);
    15151515    cachedResourceRequest.setInitiator(*this);
    15161516    m_mainResource = m_cachedResourceLoader->requestMainResource(cachedResourceRequest);
  • trunk/Source/WebCore/loader/DocumentThreadableLoader.cpp

    r203900 r203971  
    5757namespace WebCore {
    5858
    59 void DocumentThreadableLoader::loadResourceSynchronously(Document& document, const ResourceRequest& request, ThreadableLoaderClient& client, const ThreadableLoaderOptions& options, RefPtr<SecurityOrigin>&& origin, std::unique_ptr<ContentSecurityPolicy>&& contentSecurityPolicy)
     59void DocumentThreadableLoader::loadResourceSynchronously(Document& document, ResourceRequest&& request, ThreadableLoaderClient& client, const ThreadableLoaderOptions& options, RefPtr<SecurityOrigin>&& origin, std::unique_ptr<ContentSecurityPolicy>&& contentSecurityPolicy)
    6060{
    6161    // The loader will be deleted as soon as this function exits.
    62     RefPtr<DocumentThreadableLoader> loader = adoptRef(new DocumentThreadableLoader(document, client, LoadSynchronously, request, options, WTFMove(origin), WTFMove(contentSecurityPolicy)));
     62    RefPtr<DocumentThreadableLoader> loader = adoptRef(new DocumentThreadableLoader(document, client, LoadSynchronously, WTFMove(request), options, WTFMove(origin), WTFMove(contentSecurityPolicy)));
    6363    ASSERT(loader->hasOneRef());
    6464}
    6565
    66 void DocumentThreadableLoader::loadResourceSynchronously(Document& document, const ResourceRequest& request, ThreadableLoaderClient& client, const ThreadableLoaderOptions& options)
    67 {
    68     loadResourceSynchronously(document, request, client, options, nullptr, nullptr);
    69 }
    70 
    71 RefPtr<DocumentThreadableLoader> DocumentThreadableLoader::create(Document& document, ThreadableLoaderClient& client, const ResourceRequest& request, const ThreadableLoaderOptions& options, RefPtr<SecurityOrigin>&& origin, std::unique_ptr<ContentSecurityPolicy>&& contentSecurityPolicy)
    72 {
    73     RefPtr<DocumentThreadableLoader> loader = adoptRef(new DocumentThreadableLoader(document, client, LoadAsynchronously, request, options, WTFMove(origin), WTFMove(contentSecurityPolicy)));
     66void DocumentThreadableLoader::loadResourceSynchronously(Document& document, ResourceRequest&& request, ThreadableLoaderClient& client, const ThreadableLoaderOptions& options)
     67{
     68    loadResourceSynchronously(document, WTFMove(request), client, options, nullptr, nullptr);
     69}
     70
     71RefPtr<DocumentThreadableLoader> DocumentThreadableLoader::create(Document& document, ThreadableLoaderClient& client, ResourceRequest&& request, const ThreadableLoaderOptions& options, RefPtr<SecurityOrigin>&& origin, std::unique_ptr<ContentSecurityPolicy>&& contentSecurityPolicy)
     72{
     73    RefPtr<DocumentThreadableLoader> loader = adoptRef(new DocumentThreadableLoader(document, client, LoadAsynchronously, WTFMove(request), options, WTFMove(origin), WTFMove(contentSecurityPolicy)));
    7474    if (!loader->isLoading())
    7575        loader = nullptr;
     
    7777}
    7878
    79 RefPtr<DocumentThreadableLoader> DocumentThreadableLoader::create(Document& document, ThreadableLoaderClient& client, const ResourceRequest& request, const ThreadableLoaderOptions& options)
    80 {
    81     return create(document, client, request, options, nullptr, nullptr);
    82 }
    83 
    84 DocumentThreadableLoader::DocumentThreadableLoader(Document& document, ThreadableLoaderClient& client, BlockingBehavior blockingBehavior, const ResourceRequest& request, const ThreadableLoaderOptions& options, RefPtr<SecurityOrigin>&& origin, std::unique_ptr<ContentSecurityPolicy>&& contentSecurityPolicy)
     79RefPtr<DocumentThreadableLoader> DocumentThreadableLoader::create(Document& document, ThreadableLoaderClient& client, ResourceRequest&& request, const ThreadableLoaderOptions& options)
     80{
     81    return create(document, client, WTFMove(request), options, nullptr, nullptr);
     82}
     83
     84DocumentThreadableLoader::DocumentThreadableLoader(Document& document, ThreadableLoaderClient& client, BlockingBehavior blockingBehavior, ResourceRequest&& request, const ThreadableLoaderOptions& options, RefPtr<SecurityOrigin>&& origin, std::unique_ptr<ContentSecurityPolicy>&& contentSecurityPolicy)
    8585    : m_client(&client)
    8686    , m_document(document)
     
    100100
    101101    if (m_sameOriginRequest || m_options.mode == FetchOptions::Mode::NoCors) {
    102         loadRequest(request, DoSecurityCheck);
     102        loadRequest(WTFMove(request), DoSecurityCheck);
    103103        return;
    104104    }
     
    109109    }
    110110
    111     makeCrossOriginAccessRequest(request);
    112 }
    113 
    114 void DocumentThreadableLoader::makeCrossOriginAccessRequest(const ResourceRequest& request)
     111    makeCrossOriginAccessRequest(WTFMove(request));
     112}
     113
     114void DocumentThreadableLoader::makeCrossOriginAccessRequest(ResourceRequest&& request)
    115115{
    116116    ASSERT(m_options.mode == FetchOptions::Mode::Cors);
    117117
    118118    if ((m_options.preflightPolicy == ConsiderPreflight && isSimpleCrossOriginAccessRequest(request.httpMethod(), request.httpHeaderFields())) || m_options.preflightPolicy == PreventPreflight)
    119         makeSimpleCrossOriginAccessRequest(request);
     119        makeSimpleCrossOriginAccessRequest(WTFMove(request));
    120120    else {
    121121        m_simpleRequest = false;
    122122        if (CrossOriginPreflightResultCache::singleton().canSkipPreflight(securityOrigin().toString(), request.url(), m_options.allowCredentials(), request.httpMethod(), request.httpHeaderFields()))
    123             preflightSuccess(ResourceRequest(request));
     123            preflightSuccess(WTFMove(request));
    124124        else
    125             makeCrossOriginAccessRequestWithPreflight(ResourceRequest(request));
    126     }
    127 }
    128 
    129 void DocumentThreadableLoader::makeSimpleCrossOriginAccessRequest(const ResourceRequest& request)
     125            makeCrossOriginAccessRequestWithPreflight(WTFMove(request));
     126    }
     127}
     128
     129void DocumentThreadableLoader::makeSimpleCrossOriginAccessRequest(ResourceRequest&& request)
    130130{
    131131    ASSERT(m_options.preflightPolicy != ForcePreflight);
     
    138138    }
    139139
    140     auto crossOriginRequest = request;
    141     updateRequestForAccessControl(crossOriginRequest, securityOrigin(), m_options.allowCredentials());
    142     loadRequest(crossOriginRequest, DoSecurityCheck);
     140    updateRequestForAccessControl(request, securityOrigin(), m_options.allowCredentials());
     141    loadRequest(WTFMove(request), DoSecurityCheck);
    143142}
    144143
     
    251250            cleanRedirectedRequestForAccessControl(request);
    252251
    253             makeCrossOriginAccessRequest(request);
     252            makeCrossOriginAccessRequest(ResourceRequest(request));
    254253            return;
    255254        }
     
    341340
    342341    // It should be ok to skip the security check since we already asked about the preflight request.
    343     loadRequest(actualRequest, SkipSecurityCheck);
     342    loadRequest(WTFMove(actualRequest), SkipSecurityCheck);
    344343}
    345344
     
    355354}
    356355
    357 void DocumentThreadableLoader::loadRequest(const ResourceRequest& request, SecurityCheckPolicy securityCheck)
     356void DocumentThreadableLoader::loadRequest(ResourceRequest&& request, SecurityCheckPolicy securityCheck)
    358357{
    359358    // Any credential should have been removed from the cross-site requests.
     
    370369        options.mode = FetchOptions::Mode::NoCors;
    371370
    372         CachedResourceRequest newRequest(request, options);
     371        CachedResourceRequest newRequest(WTFMove(request), options);
    373372        if (RuntimeEnabledFeatures::sharedFeatures().resourceTimingEnabled())
    374373            newRequest.setInitiator(m_options.initiator);
  • trunk/Source/WebCore/loader/DocumentThreadableLoader.h

    r203815 r203971  
    4646        WTF_MAKE_FAST_ALLOCATED;
    4747    public:
    48         static void loadResourceSynchronously(Document&, const ResourceRequest&, ThreadableLoaderClient&, const ThreadableLoaderOptions&, RefPtr<SecurityOrigin>&&, std::unique_ptr<ContentSecurityPolicy>&&);
    49         static void loadResourceSynchronously(Document&, const ResourceRequest&, ThreadableLoaderClient&, const ThreadableLoaderOptions&);
     48        static void loadResourceSynchronously(Document&, ResourceRequest&&, ThreadableLoaderClient&, const ThreadableLoaderOptions&, RefPtr<SecurityOrigin>&&, std::unique_ptr<ContentSecurityPolicy>&&);
     49        static void loadResourceSynchronously(Document&, ResourceRequest&&, ThreadableLoaderClient&, const ThreadableLoaderOptions&);
    5050
    51         static RefPtr<DocumentThreadableLoader> create(Document&, ThreadableLoaderClient&, const ResourceRequest&, const ThreadableLoaderOptions&, RefPtr<SecurityOrigin>&&, std::unique_ptr<ContentSecurityPolicy>&&);
    52         static RefPtr<DocumentThreadableLoader> create(Document&, ThreadableLoaderClient&, const ResourceRequest&, const ThreadableLoaderOptions&);
     51        static RefPtr<DocumentThreadableLoader> create(Document&, ThreadableLoaderClient&, ResourceRequest&&, const ThreadableLoaderOptions&, RefPtr<SecurityOrigin>&&, std::unique_ptr<ContentSecurityPolicy>&&);
     52        static RefPtr<DocumentThreadableLoader> create(Document&, ThreadableLoaderClient&, ResourceRequest&&, const ThreadableLoaderOptions&);
    5353
    5454        virtual ~DocumentThreadableLoader();
     
    7272        };
    7373
    74         DocumentThreadableLoader(Document&, ThreadableLoaderClient&, BlockingBehavior, const ResourceRequest&, const ThreadableLoaderOptions&, RefPtr<SecurityOrigin>&&, std::unique_ptr<ContentSecurityPolicy>&&);
     74        DocumentThreadableLoader(Document&, ThreadableLoaderClient&, BlockingBehavior, ResourceRequest&&, const ThreadableLoaderOptions&, RefPtr<SecurityOrigin>&&, std::unique_ptr<ContentSecurityPolicy>&&);
    7575
    7676        void clearResource();
     
    8787        void didFinishLoading(unsigned long identifier, double finishTime);
    8888        void didFail(unsigned long identifier, const ResourceError&);
    89         void makeCrossOriginAccessRequest(const ResourceRequest&);
    90         void makeSimpleCrossOriginAccessRequest(const ResourceRequest&);
     89        void makeCrossOriginAccessRequest(ResourceRequest&&);
     90        void makeSimpleCrossOriginAccessRequest(ResourceRequest&&);
    9191        void makeCrossOriginAccessRequestWithPreflight(ResourceRequest&&);
    9292        void preflightSuccess(ResourceRequest&&);
    9393        void preflightFailure(unsigned long identifier, const ResourceError&);
    9494
    95         void loadRequest(const ResourceRequest&, SecurityCheckPolicy);
     95        void loadRequest(ResourceRequest&&, SecurityCheckPolicy);
    9696        bool isAllowedRedirect(const URL&);
    9797        bool isAllowedByContentSecurityPolicy(const URL&, bool didRedirect = false);
  • trunk/Source/WebCore/loader/MediaResourceLoader.cpp

    r203720 r203971  
    6666    auto cachingPolicy = options & LoadOption::DisallowCaching ? CachingPolicy::DisallowCaching : CachingPolicy::AllowCaching;
    6767
     68    // FIXME: We should try to remove the copy of request when crearing cacheRequest.
    6869    // FIXME: Skip Content Security Policy check if the element that inititated this request is in a user-agent shadow tree. See <https://bugs.webkit.org/show_bug.cgi?id=155505>.
    69     CachedResourceRequest cacheRequest(request, ResourceLoaderOptions(SendCallbacks, DoNotSniffContent, bufferingPolicy, AllowStoredCredentials, ClientCredentialPolicy::MayAskClientForCredentials, FetchOptions::Credentials::Include, DoSecurityCheck, FetchOptions::Mode::NoCors, DoNotIncludeCertificateInfo, ContentSecurityPolicyImposition::DoPolicyCheck, DefersLoadingPolicy::AllowDefersLoading, cachingPolicy));
     70    CachedResourceRequest cacheRequest(ResourceRequest(request), ResourceLoaderOptions(SendCallbacks, DoNotSniffContent, bufferingPolicy, AllowStoredCredentials, ClientCredentialPolicy::MayAskClientForCredentials, FetchOptions::Credentials::Include, DoSecurityCheck, FetchOptions::Mode::NoCors, DoNotIncludeCertificateInfo, ContentSecurityPolicyImposition::DoPolicyCheck, DefersLoadingPolicy::AllowDefersLoading, cachingPolicy));
    7071
    7172    cacheRequest.setAsPotentiallyCrossOrigin(m_crossOriginMode, *m_document);
  • trunk/Source/WebCore/loader/ThreadableLoader.cpp

    r203490 r203971  
    5959}
    6060
    61 RefPtr<ThreadableLoader> ThreadableLoader::create(ScriptExecutionContext* context, ThreadableLoaderClient* client, const ResourceRequest& request, const ThreadableLoaderOptions& options)
     61RefPtr<ThreadableLoader> ThreadableLoader::create(ScriptExecutionContext* context, ThreadableLoaderClient* client, ResourceRequest&& request, const ThreadableLoaderOptions& options)
    6262{
    6363    ASSERT(client);
     
    6565
    6666    if (is<WorkerGlobalScope>(*context))
    67         return WorkerThreadableLoader::create(downcast<WorkerGlobalScope>(context), client, WorkerRunLoop::defaultMode(), request, options);
     67        return WorkerThreadableLoader::create(downcast<WorkerGlobalScope>(context), client, WorkerRunLoop::defaultMode(), WTFMove(request), options);
    6868
    69     return DocumentThreadableLoader::create(downcast<Document>(*context), *client, request, options);
     69    return DocumentThreadableLoader::create(downcast<Document>(*context), *client, WTFMove(request), options);
    7070}
    7171
    72 void ThreadableLoader::loadResourceSynchronously(ScriptExecutionContext* context, const ResourceRequest& request, ThreadableLoaderClient& client, const ThreadableLoaderOptions& options)
     72void ThreadableLoader::loadResourceSynchronously(ScriptExecutionContext* context, ResourceRequest&& request, ThreadableLoaderClient& client, const ThreadableLoaderOptions& options)
    7373{
    7474    ASSERT(context);
    7575
    7676    if (is<WorkerGlobalScope>(*context))
    77         WorkerThreadableLoader::loadResourceSynchronously(downcast<WorkerGlobalScope>(context), request, client, options);
     77        WorkerThreadableLoader::loadResourceSynchronously(downcast<WorkerGlobalScope>(context), WTFMove(request), client, options);
    7878    else
    79         DocumentThreadableLoader::loadResourceSynchronously(downcast<Document>(*context), request, client, options);
    80     context->didLoadResourceSynchronously(request);
     79        DocumentThreadableLoader::loadResourceSynchronously(downcast<Document>(*context), WTFMove(request), client, options);
     80    context->didLoadResourceSynchronously();
    8181}
    8282
  • trunk/Source/WebCore/loader/ThreadableLoader.h

    r203490 r203971  
    7070    };
    7171
    72     // Useful for doing loader operations from any thread (not threadsafe, 
     72    // Useful for doing loader operations from any thread (not threadsafe,
    7373    // just able to run on threads other than the main thread).
    7474    class ThreadableLoader {
    7575        WTF_MAKE_NONCOPYABLE(ThreadableLoader);
    7676    public:
    77         static void loadResourceSynchronously(ScriptExecutionContext*, const ResourceRequest&, ThreadableLoaderClient&, const ThreadableLoaderOptions&);
    78         static RefPtr<ThreadableLoader> create(ScriptExecutionContext*, ThreadableLoaderClient*, const ResourceRequest&, const ThreadableLoaderOptions&);
     77        static void loadResourceSynchronously(ScriptExecutionContext*, ResourceRequest&&, ThreadableLoaderClient&, const ThreadableLoaderOptions&);
     78        static RefPtr<ThreadableLoader> create(ScriptExecutionContext*, ThreadableLoaderClient*, ResourceRequest&&, const ThreadableLoaderOptions&);
    7979
    8080        virtual void cancel() = 0;
  • trunk/Source/WebCore/loader/WorkerThreadableLoader.cpp

    r203490 r203971  
    5050static const char loadResourceSynchronouslyMode[] = "loadResourceSynchronouslyMode";
    5151
    52 WorkerThreadableLoader::WorkerThreadableLoader(WorkerGlobalScope* workerGlobalScope, ThreadableLoaderClient* client, const String& taskMode, const ResourceRequest& request, const ThreadableLoaderOptions& options)
     52WorkerThreadableLoader::WorkerThreadableLoader(WorkerGlobalScope* workerGlobalScope, ThreadableLoaderClient* client, const String& taskMode, ResourceRequest&& request, const ThreadableLoaderOptions& options)
    5353    : m_workerGlobalScope(workerGlobalScope)
    5454    , m_workerClientWrapper(ThreadableLoaderClientWrapper::create(client))
    55     , m_bridge(*new MainThreadBridge(*m_workerClientWrapper, workerGlobalScope->thread().workerLoaderProxy(), taskMode, request, options, workerGlobalScope->url().strippedForUseAsReferrer(), workerGlobalScope->securityOrigin(), workerGlobalScope->contentSecurityPolicy()))
     55    , m_bridge(*new MainThreadBridge(*m_workerClientWrapper, workerGlobalScope->thread().workerLoaderProxy(), taskMode, WTFMove(request), options, workerGlobalScope->url().strippedForUseAsReferrer(), workerGlobalScope->securityOrigin(), workerGlobalScope->contentSecurityPolicy()))
    5656{
    5757}
     
    6262}
    6363
    64 void WorkerThreadableLoader::loadResourceSynchronously(WorkerGlobalScope* workerGlobalScope, const ResourceRequest& request, ThreadableLoaderClient& client, const ThreadableLoaderOptions& options)
     64void WorkerThreadableLoader::loadResourceSynchronously(WorkerGlobalScope* workerGlobalScope, ResourceRequest&& request, ThreadableLoaderClient& client, const ThreadableLoaderOptions& options)
    6565{
    6666    WorkerRunLoop& runLoop = workerGlobalScope->thread().runLoop();
     
    7070    mode.append(String::number(runLoop.createUniqueId()));
    7171
    72     RefPtr<WorkerThreadableLoader> loader = WorkerThreadableLoader::create(workerGlobalScope, &client, mode, request, options);
     72    RefPtr<WorkerThreadableLoader> loader = WorkerThreadableLoader::create(workerGlobalScope, &client, mode, WTFMove(request), options);
    7373    MessageQueueWaitResult result = MessageQueueMessageReceived;
    7474    while (!loader->done() && result != MessageQueueTerminated)
     
    9999
    100100WorkerThreadableLoader::MainThreadBridge::MainThreadBridge(ThreadableLoaderClientWrapper& workerClientWrapper, WorkerLoaderProxy& loaderProxy, const String& taskMode,
    101     const ResourceRequest& request, const ThreadableLoaderOptions& options, const String& outgoingReferrer,
     101    ResourceRequest&& request, const ThreadableLoaderOptions& options, const String& outgoingReferrer,
    102102    const SecurityOrigin* securityOrigin, const ContentSecurityPolicy* contentSecurityPolicy)
    103103    : m_workerClientWrapper(&workerClientWrapper)
     
    113113    auto optionsCopy = std::make_unique<LoaderTaskOptions>(options, outgoingReferrer, *securityOrigin);
    114114
     115    // Can we benefit from request being an r-value to create more efficiently its isolated copy?
    115116    m_loaderProxy.postTaskToLoader([this, request = request.isolatedCopy(), options = WTFMove(optionsCopy), contentSecurityPolicyCopy = WTFMove(contentSecurityPolicyCopy)](ScriptExecutionContext& context) mutable {
    116117        ASSERT(isMainThread());
     
    121122        // FIXME: If the site requests a local resource, then this will return a non-zero value but the sync path will return a 0 value.
    122123        // Either this should return 0 or the other code path should call a failure callback.
    123         m_mainThreadLoader = DocumentThreadableLoader::create(document, *this, request, options->options, WTFMove(options->origin), WTFMove(contentSecurityPolicyCopy));
     124        m_mainThreadLoader = DocumentThreadableLoader::create(document, *this, WTFMove(request), options->options, WTFMove(options->origin), WTFMove(contentSecurityPolicyCopy));
    124125        ASSERT(m_mainThreadLoader || m_loadingFinished);
    125126    });
  • trunk/Source/WebCore/loader/WorkerThreadableLoader.h

    r202542 r203971  
    5050        WTF_MAKE_FAST_ALLOCATED;
    5151    public:
    52         static void loadResourceSynchronously(WorkerGlobalScope*, const ResourceRequest&, ThreadableLoaderClient&, const ThreadableLoaderOptions&);
    53         static Ref<WorkerThreadableLoader> create(WorkerGlobalScope* workerGlobalScope, ThreadableLoaderClient* client, const String& taskMode, const ResourceRequest& request, const ThreadableLoaderOptions& options)
     52        static void loadResourceSynchronously(WorkerGlobalScope*, ResourceRequest&&, ThreadableLoaderClient&, const ThreadableLoaderOptions&);
     53        static Ref<WorkerThreadableLoader> create(WorkerGlobalScope* workerGlobalScope, ThreadableLoaderClient* client, const String& taskMode, ResourceRequest&& request, const ThreadableLoaderOptions& options)
    5454        {
    55             return adoptRef(*new WorkerThreadableLoader(workerGlobalScope, client, taskMode, request, options));
     55            return adoptRef(*new WorkerThreadableLoader(workerGlobalScope, client, taskMode, WTFMove(request), options));
    5656        }
    5757
     
    9191        public:
    9292            // All executed on the worker context's thread.
    93             MainThreadBridge(ThreadableLoaderClientWrapper&, WorkerLoaderProxy&, const String& taskMode, const ResourceRequest&, const ThreadableLoaderOptions&, const String& outgoingReferrer, const SecurityOrigin*, const ContentSecurityPolicy*);
     93            MainThreadBridge(ThreadableLoaderClientWrapper&, WorkerLoaderProxy&, const String& taskMode, ResourceRequest&&, const ThreadableLoaderOptions&, const String& outgoingReferrer, const SecurityOrigin*, const ContentSecurityPolicy*);
    9494            void cancel();
    9595            void destroy();
     
    121121        };
    122122
    123         WorkerThreadableLoader(WorkerGlobalScope*, ThreadableLoaderClient*, const String& taskMode, const ResourceRequest&, const ThreadableLoaderOptions&);
     123        WorkerThreadableLoader(WorkerGlobalScope*, ThreadableLoaderClient*, const String& taskMode, ResourceRequest&&, const ThreadableLoaderOptions&);
    124124
    125125        RefPtr<WorkerGlobalScope> m_workerGlobalScope;
  • trunk/Source/WebCore/loader/cache/CachedResourceRequest.cpp

    r202815 r203971  
    4545}
    4646
    47 CachedResourceRequest::CachedResourceRequest(const ResourceRequest& resourceRequest, const ResourceLoaderOptions& options)
    48     : m_resourceRequest(resourceRequest)
     47CachedResourceRequest::CachedResourceRequest(ResourceRequest&& resourceRequest, const ResourceLoaderOptions& options)
     48    : m_resourceRequest(WTFMove(resourceRequest))
    4949    , m_options(options)
    5050    , m_forPreload(false)
  • trunk/Source/WebCore/loader/cache/CachedResourceRequest.h

    r201930 r203971  
    4343
    4444    explicit CachedResourceRequest(const ResourceRequest&, const String& charset = String(), Optional<ResourceLoadPriority> = Nullopt);
    45     CachedResourceRequest(const ResourceRequest&, const ResourceLoaderOptions&);
     45    CachedResourceRequest(ResourceRequest&&, const ResourceLoaderOptions&);
    4646    CachedResourceRequest(const ResourceRequest&, Optional<ResourceLoadPriority>);
    4747    ~CachedResourceRequest();
  • trunk/Source/WebCore/page/EventSource.cpp

    r203900 r203971  
    113113    options.contentSecurityPolicyEnforcement = scriptExecutionContext()->shouldBypassMainWorldContentSecurityPolicy() ? ContentSecurityPolicyEnforcement::DoNotEnforce : ContentSecurityPolicyEnforcement::EnforceConnectSrcDirective;
    114114
    115     m_loader = ThreadableLoader::create(scriptExecutionContext(), this, request, options);
     115    m_loader = ThreadableLoader::create(scriptExecutionContext(), this, WTFMove(request), options);
    116116
    117117    // FIXME: Can we just use m_loader for this, null it out when it's no longer in flight, and eliminate the m_requestInFlight member?
  • trunk/Source/WebCore/workers/WorkerScriptLoader.cpp

    r203900 r203971  
    7474    options.contentSecurityPolicyEnforcement = contentSecurityPolicyEnforcement;
    7575
    76     WorkerThreadableLoader::loadResourceSynchronously(downcast<WorkerGlobalScope>(scriptExecutionContext), *request, *this, options);
     76    WorkerThreadableLoader::loadResourceSynchronously(downcast<WorkerGlobalScope>(scriptExecutionContext), WTFMove(*request), *this, options);
    7777}
    7878
     
    9999    // During create, callbacks may happen which remove the last reference to this object.
    100100    Ref<WorkerScriptLoader> protectedThis(*this);
    101     m_threadableLoader = ThreadableLoader::create(scriptExecutionContext, this, *request, options);
     101    m_threadableLoader = ThreadableLoader::create(scriptExecutionContext, this, WTFMove(*request), options);
    102102}
    103103
  • trunk/Source/WebCore/xml/XMLHttpRequest.cpp

    r203900 r203971  
    715715        // This is true while running onunload handlers.
    716716        // FIXME: Maybe we need to be able to send XMLHttpRequests from onunload, <http://bugs.webkit.org/show_bug.cgi?id=10904>.
    717         m_loader = ThreadableLoader::create(scriptExecutionContext(), this, request, options);
     717        m_loader = ThreadableLoader::create(scriptExecutionContext(), this, WTFMove(request), options);
    718718
    719719        // Neither this object nor the JavaScript wrapper should be deleted while
     
    728728    } else {
    729729        InspectorInstrumentation::willLoadXHRSynchronously(scriptExecutionContext());
    730         ThreadableLoader::loadResourceSynchronously(scriptExecutionContext(), request, *this, options);
     730        ThreadableLoader::loadResourceSynchronously(scriptExecutionContext(), WTFMove(request), *this, options);
    731731        InspectorInstrumentation::didLoadXHRSynchronously(scriptExecutionContext());
    732732    }
Note: See TracChangeset for help on using the changeset viewer.