Changeset 201708 in webkit


Ignore:
Timestamp:
Jun 6, 2016 1:25:16 AM (8 years ago)
Author:
commit-queue@webkit.org
Message:

Reduce ResourceRequest copying in loading code
​https://bugs.webkit.org/show_bug.cgi?id=158251

Patch by Alex Christensen <​achristensen@webkit.org> on 2016-06-06
Reviewed by Darin Adler.

Source/WebCore:

No new tests. There should be no change in behavior except fewer unnecessary copies.
Before, we would pass a const ResourceRequest& around, and if we needed to modify it
we would copy the whole thing, modify the copy, and pass the copy along. This can be
accomplished with move semantics without the now-unnecessary copy.

The biggest conceptual change is that the synchronous ResourceHandleClient::willSendRequest
used to take a non-const ResourceRequest& and modify it, but now it returns a modified
ResourceRequest instead.

  • loader/ResourceLoader.cpp:

(WebCore::ResourceLoader::cannotShowURLError):
(WebCore::ResourceLoader::willSendRequest):
(WebCore::ResourceLoader::didSendData):

  • loader/ResourceLoader.h:
  • platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:

(ResourceHandleStreamingClient::getOrCreateReadBuffer):
(ResourceHandleStreamingClient::willSendRequest):
(ResourceHandleStreamingClient::didReceiveResponse):

  • platform/network/ResourceHandle.h:
  • platform/network/ResourceHandleClient.cpp:

(WebCore::ResourceHandleClient::~ResourceHandleClient):
(WebCore::ResourceHandleClient::willSendRequest):
(WebCore::ResourceHandleClient::willSendRequestAsync):
(WebCore::ResourceHandleClient::didReceiveResponseAsync):

  • platform/network/ResourceHandleClient.h:

(WebCore::ResourceHandleClient::didSendData):
(WebCore::ResourceHandleClient::didReceiveResponse):
(WebCore::ResourceHandleClient::loadingSynchronousXHR):
(WebCore::ResourceHandleClient::willSendRequest): Deleted.

  • platform/network/SynchronousLoaderClient.cpp:

(WebCore::SynchronousLoaderClient::~SynchronousLoaderClient):
(WebCore::SynchronousLoaderClient::willSendRequest):
(WebCore::SynchronousLoaderClient::shouldUseCredentialStorage):

  • platform/network/SynchronousLoaderClient.h:
  • platform/network/cf/ResourceHandleCFNet.cpp:

(WebCore::ResourceHandle::cancel):
(WebCore::ResourceHandle::willSendRequest):

  • platform/network/cf/ResourceHandleCFURLConnectionDelegateWithOperationQueue.cpp:

(WebCore::ResourceHandleCFURLConnectionDelegateWithOperationQueue::willSendRequest):

  • platform/network/cf/SynchronousResourceHandleCFURLConnectionDelegate.cpp:

(WebCore::SynchronousResourceHandleCFURLConnectionDelegate::willSendRequest):

  • platform/network/mac/ResourceHandleMac.mm:

(WebCore::ResourceHandle::platformLoadResourceSynchronously):
(WebCore::ResourceHandle::willSendRequest):
(WebCore::ResourceHandle::continueWillSendRequest):

  • platform/network/mac/WebCoreResourceHandleAsDelegate.mm:

(-[WebCoreResourceHandleAsDelegate connection:willSendRequest:redirectResponse:]):
(-[WebCoreResourceHandleAsDelegate connectionShouldUseCredentialStorage:]):

  • platform/network/mac/WebCoreResourceHandleAsOperationQueueDelegate.mm:

(-[WebCoreResourceHandleAsOperationQueueDelegate connection:willSendRequest:redirectResponse:]):

  • platform/network/soup/ResourceHandleSoup.cpp:

(WebCore::shouldRedirectAsGET):
(WebCore::continueAfterWillSendRequest):
(WebCore::readCallback):
(WebCore::ResourceHandle::continueWillSendRequest):
(WebCore::ResourceHandle::continueDidReceiveResponse):

Source/WebKit2:

  • NetworkProcess/Downloads/DownloadManager.cpp:

(WebKit::DownloadManager::continueCanAuthenticateAgainstProtectionSpace):
(WebKit::DownloadManager::continueWillSendRequest):
(WebKit::DownloadManager::willDecidePendingDownloadDestination):

  • NetworkProcess/Downloads/DownloadManager.h:
  • NetworkProcess/Downloads/PendingDownload.cpp:

(WebKit::PendingDownload::PendingDownload):
(WebKit::PendingDownload::willSendRedirectedRequest):
(WebKit::PendingDownload::continueWillSendRequest):
(WebKit::PendingDownload::canAuthenticateAgainstProtectionSpaceAsync):

  • NetworkProcess/Downloads/PendingDownload.h:
  • NetworkProcess/NetworkDataTask.h:

(WebKit::NetworkDataTask::firstRequest):

  • NetworkProcess/NetworkLoad.cpp:

(WebKit::NetworkLoad::cancel):
(WebKit::NetworkLoad::continueWillSendRequest):
(WebKit::NetworkLoad::sharedDidReceiveResponse):
(WebKit::NetworkLoad::sharedWillSendRedirectedRequest):
(WebKit::NetworkLoad::setPendingDownload):
(WebKit::NetworkLoad::willPerformHTTPRedirection):
(WebKit::NetworkLoad::didReceiveChallenge):
(WebKit::NetworkLoad::didFail):
(WebKit::NetworkLoad::willSendRequestAsync):

  • NetworkProcess/NetworkLoad.h:

(WebKit::NetworkLoad::currentRequest):
(WebKit::NetworkLoad::clearCurrentRequest):
(WebKit::NetworkLoad::pendingDownloadID):

  • NetworkProcess/NetworkLoadClient.h:
  • NetworkProcess/NetworkProcess.cpp:

(WebKit::NetworkProcess::continueCanAuthenticateAgainstProtectionSpace):
(WebKit::NetworkProcess::continueWillSendRequest):
(WebKit::NetworkProcess::pendingDownloadCanceled):

  • NetworkProcess/NetworkProcess.h:
  • NetworkProcess/NetworkResourceLoader.cpp:

(WebKit::NetworkResourceLoader::didFailLoading):
(WebKit::NetworkResourceLoader::willSendRedirectedRequest):
(WebKit::NetworkResourceLoader::continueWillSendRequest):
(WebKit::NetworkResourceLoader::continueDidReceiveResponse):

  • NetworkProcess/NetworkResourceLoader.h:
  • NetworkProcess/PingLoad.h:

(WebKit::PingLoad::PingLoad):

  • NetworkProcess/cache/NetworkCacheSpeculativeLoad.cpp:

(WebKit::NetworkCache::SpeculativeLoad::~SpeculativeLoad):
(WebKit::NetworkCache::SpeculativeLoad::willSendRedirectedRequest):

  • NetworkProcess/cache/NetworkCacheSpeculativeLoad.h:
  • NetworkProcess/cocoa/NetworkDataTaskCocoa.mm:

(WebKit::NetworkDataTask::didBecomeDownload):
(WebKit::NetworkDataTask::willPerformHTTPRedirection):

  • WebProcess/Network/WebResourceLoader.cpp:

(WebKit::WebResourceLoader::detachFromCoreLoader):
(WebKit::WebResourceLoader::willSendRequest):

  • WebProcess/Network/WebResourceLoader.h:
Location:
trunk/Source
Files:
35 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r201706 r201708  
     12016-06-06  Alex Christensen  <achristensen@webkit.org>
     2
     3        Reduce ResourceRequest copying in loading code
     4        https://bugs.webkit.org/show_bug.cgi?id=158251
     5
     6        Reviewed by Darin Adler.
     7
     8        No new tests. There should be no change in behavior except fewer unnecessary copies.
     9        Before, we would pass a const ResourceRequest& around, and if we needed to modify it
     10        we would copy the whole thing, modify the copy, and pass the copy along.  This can be
     11        accomplished with move semantics without the now-unnecessary copy.
     12       
     13        The biggest conceptual change is that the synchronous ResourceHandleClient::willSendRequest
     14        used to take a non-const ResourceRequest& and modify it, but now it returns a modified
     15        ResourceRequest instead.
     16
     17        * loader/ResourceLoader.cpp:
     18        (WebCore::ResourceLoader::cannotShowURLError):
     19        (WebCore::ResourceLoader::willSendRequest):
     20        (WebCore::ResourceLoader::didSendData):
     21        * loader/ResourceLoader.h:
     22        * platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp:
     23        (ResourceHandleStreamingClient::getOrCreateReadBuffer):
     24        (ResourceHandleStreamingClient::willSendRequest):
     25        (ResourceHandleStreamingClient::didReceiveResponse):
     26        * platform/network/ResourceHandle.h:
     27        * platform/network/ResourceHandleClient.cpp:
     28        (WebCore::ResourceHandleClient::~ResourceHandleClient):
     29        (WebCore::ResourceHandleClient::willSendRequest):
     30        (WebCore::ResourceHandleClient::willSendRequestAsync):
     31        (WebCore::ResourceHandleClient::didReceiveResponseAsync):
     32        * platform/network/ResourceHandleClient.h:
     33        (WebCore::ResourceHandleClient::didSendData):
     34        (WebCore::ResourceHandleClient::didReceiveResponse):
     35        (WebCore::ResourceHandleClient::loadingSynchronousXHR):
     36        (WebCore::ResourceHandleClient::willSendRequest): Deleted.
     37        * platform/network/SynchronousLoaderClient.cpp:
     38        (WebCore::SynchronousLoaderClient::~SynchronousLoaderClient):
     39        (WebCore::SynchronousLoaderClient::willSendRequest):
     40        (WebCore::SynchronousLoaderClient::shouldUseCredentialStorage):
     41        * platform/network/SynchronousLoaderClient.h:
     42        * platform/network/cf/ResourceHandleCFNet.cpp:
     43        (WebCore::ResourceHandle::cancel):
     44        (WebCore::ResourceHandle::willSendRequest):
     45        * platform/network/cf/ResourceHandleCFURLConnectionDelegateWithOperationQueue.cpp:
     46        (WebCore::ResourceHandleCFURLConnectionDelegateWithOperationQueue::willSendRequest):
     47        * platform/network/cf/SynchronousResourceHandleCFURLConnectionDelegate.cpp:
     48        (WebCore::SynchronousResourceHandleCFURLConnectionDelegate::willSendRequest):
     49        * platform/network/mac/ResourceHandleMac.mm:
     50        (WebCore::ResourceHandle::platformLoadResourceSynchronously):
     51        (WebCore::ResourceHandle::willSendRequest):
     52        (WebCore::ResourceHandle::continueWillSendRequest):
     53        * platform/network/mac/WebCoreResourceHandleAsDelegate.mm:
     54        (-[WebCoreResourceHandleAsDelegate connection:willSendRequest:redirectResponse:]):
     55        (-[WebCoreResourceHandleAsDelegate connectionShouldUseCredentialStorage:]):
     56        * platform/network/mac/WebCoreResourceHandleAsOperationQueueDelegate.mm:
     57        (-[WebCoreResourceHandleAsOperationQueueDelegate connection:willSendRequest:redirectResponse:]):
     58        * platform/network/soup/ResourceHandleSoup.cpp:
     59        (WebCore::shouldRedirectAsGET):
     60        (WebCore::continueAfterWillSendRequest):
     61        (WebCore::readCallback):
     62        (WebCore::ResourceHandle::continueWillSendRequest):
     63        (WebCore::ResourceHandle::continueDidReceiveResponse):
     64
    1652016-06-05  Sam Weinig  <sam@webkit.org>
    266

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

    r201596 r201708  
    608608}
    609609
    610 void ResourceLoader::willSendRequest(ResourceHandle*, ResourceRequest& request, const ResourceResponse& redirectResponse)
     610ResourceRequest ResourceLoader::willSendRequest(ResourceHandle*, ResourceRequest&& request, ResourceResponse&& redirectResponse)
    611611{
    612612    if (documentLoader()->applicationCacheHost()->maybeLoadFallbackForRedirect(this, request, redirectResponse))
    613         return;
     613        return WTFMove(request);
    614614    willSendRequestInternal(request, redirectResponse);
     615    return WTFMove(request);
    615616}
    616617

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

    r201596 r201708  
    184184
    185185    // ResourceHandleClient
    186     void willSendRequest(ResourceHandle*, ResourceRequest&, const ResourceResponse& redirectResponse) override;
     186    ResourceRequest willSendRequest(ResourceHandle*, ResourceRequest&&, ResourceResponse&& redirectResponse) override;
    187187    void didSendData(ResourceHandle*, unsigned long long bytesSent, unsigned long long totalBytesToBeSent) override;
    188188    void didReceiveResponse(ResourceHandle*, const ResourceResponse&) override;

  • trunk/Source/WebCore/platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp

    r200455 r201708  
    9696        char* getOrCreateReadBuffer(size_t requestedSize, size_t& actualSize) override;
    9797#endif
    98         void willSendRequest(ResourceHandle*, ResourceRequest&, const ResourceResponse&) override;
     98        ResourceRequest willSendRequest(ResourceHandle*, ResourceRequest&&, ResourceResponse&&) override;
    9999        void didReceiveResponse(ResourceHandle*, const ResourceResponse&) override;
    100100        void didReceiveData(ResourceHandle*, const char*, unsigned, int) override;
    … …  
    10861086#endif
    10871087
    1088 void ResourceHandleStreamingClient::willSendRequest(ResourceHandle*, ResourceRequest&, const ResourceResponse&)
    1089 {
     1088ResourceRequest ResourceHandleStreamingClient::willSendRequest(ResourceHandle*, ResourceRequest&& request, ResourceResponse&&)
     1089{
     1090    return WTFMove(request);
    10901091}
    10911092

  • trunk/Source/WebCore/platform/network/ResourceHandle.h

    r198143 r201708  
    106106
    107107#if PLATFORM(COCOA) || USE(CFNETWORK)
    108     void willSendRequest(ResourceRequest&, const ResourceResponse& redirectResponse);
     108    ResourceRequest willSendRequest(ResourceRequest&&, ResourceResponse&&);
    109109#endif
    110110
    … …  
    203203
    204204    // Called in response to ResourceHandleClient::willSendRequestAsync().
    205     WEBCORE_EXPORT void continueWillSendRequest(const ResourceRequest&);
     205    WEBCORE_EXPORT void continueWillSendRequest(ResourceRequest&&);
    206206
    207207    // Called in response to ResourceHandleClient::didReceiveResponseAsync().

  • trunk/Source/WebCore/platform/network/ResourceHandleClient.cpp

    r168248 r201708  
    2828
    2929#include "ResourceHandle.h"
     30#include "ResourceRequest.h"
    3031#include "SharedBuffer.h"
    3132
    … …  
    3940{
    4041}
     42   
     43ResourceRequest ResourceHandleClient::willSendRequest(ResourceHandle*, ResourceRequest&& request, ResourceResponse&&)
     44{
     45    return WTFMove(request);
     46}
    4147
    42 void ResourceHandleClient::willSendRequestAsync(ResourceHandle* handle, const ResourceRequest& request, const ResourceResponse& /*redirectResponse*/)
     48void ResourceHandleClient::willSendRequestAsync(ResourceHandle* handle, ResourceRequest&& request, ResourceResponse&& /*redirectResponse*/)
    4349{
    44     handle->continueWillSendRequest(request);
     50    handle->continueWillSendRequest(WTFMove(request));
    4551}
    4652

  • trunk/Source/WebCore/platform/network/ResourceHandleClient.h

    r186894 r201708  
    7070        WEBCORE_EXPORT virtual ~ResourceHandleClient();
    7171
    72         // Request may be modified.
    73         virtual void willSendRequest(ResourceHandle*, ResourceRequest&, const ResourceResponse& /*redirectResponse*/) { }
     72        WEBCORE_EXPORT virtual ResourceRequest willSendRequest(ResourceHandle*, ResourceRequest&&, ResourceResponse&&);
    7473        virtual void didSendData(ResourceHandle*, unsigned long long /*bytesSent*/, unsigned long long /*totalBytesToBeSent*/) { }
    7574
    … …  
    8988
    9089        // Client will pass an updated request using ResourceHandle::continueWillSendRequest() when ready.
    91         WEBCORE_EXPORT virtual void willSendRequestAsync(ResourceHandle*, const ResourceRequest&, const ResourceResponse& redirectResponse);
     90        WEBCORE_EXPORT virtual void willSendRequestAsync(ResourceHandle*, ResourceRequest&&, ResourceResponse&&);
    9291
    9392        // Client will call ResourceHandle::continueDidReceiveResponse() when ready.

  • trunk/Source/WebCore/platform/network/SynchronousLoaderClient.cpp

    r161338 r201708  
    3737}
    3838
    39 void SynchronousLoaderClient::willSendRequest(ResourceHandle* handle, ResourceRequest& request, const ResourceResponse& /*redirectResponse*/)
     39ResourceRequest SynchronousLoaderClient::willSendRequest(ResourceHandle* handle, ResourceRequest&& request, ResourceResponse&&)
    4040{
    4141    // FIXME: This needs to be fixed to follow the redirect correctly even for cross-domain requests.
    4242    if (protocolHostAndPortAreEqual(handle->firstRequest().url(), request.url()))
    43         return;
     43        return WTFMove(request);
    4444
    4545    ASSERT(m_error.isNull());
    4646    m_error = platformBadResponseError();
    4747    m_isDone = true;
    48     request = ResourceRequest();
     48    return { };
    4949}
    5050

  • trunk/Source/WebCore/platform/network/SynchronousLoaderClient.h

    r197563 r201708  
    4646
    4747private:
    48     void willSendRequest(ResourceHandle*, ResourceRequest&, const ResourceResponse& /*redirectResponse*/) override;
     48    ResourceRequest willSendRequest(ResourceHandle*, ResourceRequest&&, ResourceResponse&&) override;
    4949    bool shouldUseCredentialStorage(ResourceHandle*) override;
    5050    void didReceiveAuthenticationChallenge(ResourceHandle*, const AuthenticationChallenge&) override;

  • trunk/Source/WebCore/platform/network/cf/ResourceHandleCFNet.cpp

    r200895 r201708  
    288288}
    289289
    290 void ResourceHandle::willSendRequest(ResourceRequest& request, const ResourceResponse& redirectResponse)
     290ResourceRequest ResourceHandle::willSendRequest(ResourceRequest&& request, ResourceResponse&& redirectResponse)
    291291{
    292292    const URL& url = request.url();
    … …  
    316316
    317317    Ref<ResourceHandle> protectedThis(*this);
    318     if (d->m_usesAsyncCallbacks)
    319         client()->willSendRequestAsync(this, request, redirectResponse);
    320     else {
    321         client()->willSendRequest(this, request, redirectResponse);
    322 
    323         // Client call may not preserve the session, especially if the request is sent over IPC.
    324         if (!request.isNull()) {
    325             request.setStorageSession(d->m_storageSession.get());
    326 
    327             d->m_currentRequest = request;
    328         }
    329     }
     318    if (d->m_usesAsyncCallbacks) {
     319        client()->willSendRequestAsync(this, WTFMove(request), WTFMove(redirectResponse));
     320        return { };
     321    }
     322   
     323    auto newRequest = client()->willSendRequest(this, WTFMove(request), WTFMove(redirectResponse));
     324
     325    // Client call may not preserve the session, especially if the request is sent over IPC.
     326    if (!newRequest.isNull()) {
     327        newRequest.setStorageSession(d->m_storageSession.get());
     328
     329        d->m_currentRequest = newRequest;
     330    }
     331    return newRequest;
    330332}
    331333
    … …  
    651653}
    652654
    653 void ResourceHandle::continueWillSendRequest(const ResourceRequest& request)
    654 {
    655     ResourceRequest requestResult = request;
    656     if (!requestResult.isNull())
    657         requestResult.setStorageSession(d->m_storageSession.get());
    658     d->m_connectionDelegate->continueWillSendRequest(requestResult.cfURLRequest(UpdateHTTPBody));
     655void ResourceHandle::continueWillSendRequest(ResourceRequest&& request)
     656{
     657    if (!request.isNull())
     658        request.setStorageSession(d->m_storageSession.get());
     659    d->m_connectionDelegate->continueWillSendRequest(request.cfURLRequest(UpdateHTTPBody));
    659660}
    660661

  • trunk/Source/WebCore/platform/network/cf/ResourceHandleCFURLConnectionDelegateWithOperationQueue.cpp

    r200917 r201708  
    119119
    120120        ResourceRequest request = createResourceRequest(cfRequest, redirectResponse.get());
    121         m_handle->willSendRequest(request, redirectResponse.get());
     121        m_handle->willSendRequest(WTFMove(request), redirectResponse.get());
    122122    });
    123123

  • trunk/Source/WebCore/platform/network/cf/SynchronousResourceHandleCFURLConnectionDelegate.cpp

    r199684 r201708  
    9393
    9494    ResourceRequest request = createResourceRequest(cfRequest, redirectResponse.get());
    95     m_handle->willSendRequest(request, redirectResponse.get());
    96 
    97     if (request.isNull())
    98         return 0;
    99 
    100     cfRequest = request.cfURLRequest(UpdateHTTPBody);
    101 
    102     CFRetain(cfRequest);
    103     return cfRequest;
     95    auto newRequest = m_handle->willSendRequest(WTFMove(request), redirectResponse.get());
     96
     97    if (newRequest.isNull())
     98        return nullptr;
     99
     100    auto newCFRequest = newRequest.cfURLRequest(UpdateHTTPBody);
     101
     102    CFRetain(newCFRequest);
     103    return newCFRequest;
    104104}
    105105

  • trunk/Source/WebCore/platform/network/mac/ResourceHandleMac.mm

    r201038 r201708  
    441441}
    442442
    443 void ResourceHandle::willSendRequest(ResourceRequest& request, const ResourceResponse& redirectResponse)
     443ResourceRequest ResourceHandle::willSendRequest(ResourceRequest&& request, ResourceResponse&& redirectResponse)
    444444{
    445445    ASSERT(!redirectResponse.isNull());
    … …  
    490490
    491491    if (d->m_usesAsyncCallbacks) {
    492         client()->willSendRequestAsync(this, request, redirectResponse);
    493     } else {
    494         Ref<ResourceHandle> protectedThis(*this);
    495         client()->willSendRequest(this, request, redirectResponse);
    496 
    497         // Client call may not preserve the session, especially if the request is sent over IPC.
    498         if (!request.isNull())
    499             request.setStorageSession(d->m_storageSession.get());
    500     }
    501 }
    502 
    503 void ResourceHandle::continueWillSendRequest(const ResourceRequest& request)
     492        client()->willSendRequestAsync(this, WTFMove(request), WTFMove(redirectResponse));
     493        return { };
     494    }
     495
     496    Ref<ResourceHandle> protectedThis(*this);
     497    auto newRequest = client()->willSendRequest(this, WTFMove(request), WTFMove(redirectResponse));
     498
     499    // Client call may not preserve the session, especially if the request is sent over IPC.
     500    if (!newRequest.isNull())
     501        newRequest.setStorageSession(d->m_storageSession.get());
     502    return newRequest;
     503}
     504
     505void ResourceHandle::continueWillSendRequest(ResourceRequest&& newRequest)
    504506{
    505507    ASSERT(d->m_usesAsyncCallbacks);
    506508
    507509    // Client call may not preserve the session, especially if the request is sent over IPC.
    508     ResourceRequest newRequest = request;
    509510    if (!newRequest.isNull())
    510511        newRequest.setStorageSession(d->m_storageSession.get());

  • trunk/Source/WebCore/platform/network/mac/WebCoreResourceHandleAsDelegate.mm

    r200655 r201708  
    7878#endif
    7979
    80     ResourceRequest request = newRequest;
    81 
    82     m_handle->willSendRequest(request, redirectResponse);
    83 
    84     return request.nsURLRequest(UpdateHTTPBody);
     80    return m_handle->willSendRequest(newRequest, redirectResponse).nsURLRequest(UpdateHTTPBody);
    8581}
    8682

  • trunk/Source/WebCore/platform/network/mac/WebCoreResourceHandleAsOperationQueueDelegate.mm

    r200655 r201708  
    123123        }
    124124
    125         ResourceRequest request = newRequest;
    126 
    127         m_handle->willSendRequest(request, redirectResponse);
     125        m_handle->willSendRequest(newRequest, redirectResponse);
    128126    });
    129127

  • trunk/Source/WebCore/platform/network/soup/ResourceHandleSoup.cpp

    r198883 r201708  
    465465}
    466466
    467 static void continueAfterWillSendRequest(ResourceHandle* handle, const ResourceRequest& request)
     467static void continueAfterWillSendRequest(ResourceHandle* handle, ResourceRequest&& request)
    468468{
    469469    // willSendRequest might cancel the load.
    … …  
    471471        return;
    472472
    473     ResourceRequest newRequest(request);
    474     ResourceHandleInternal* d = handle->getInternal();
    475     if (protocolHostAndPortAreEqual(newRequest.url(), d->m_response.url()))
    476         applyAuthenticationToRequest(handle, newRequest, true);
    477 
    478     if (!createSoupRequestAndMessageForHandle(handle, newRequest)) {
     473    ResourceHandleInternal* d = handle->getInternal();
     474    if (protocolHostAndPortAreEqual(request.url(), d->m_response.url()))
     475        applyAuthenticationToRequest(handle, request, true);
     476
     477    if (!createSoupRequestAndMessageForHandle(handle, request)) {
    479478        d->client()->cannotShowURL(handle);
    480479        return;
    … …  
    533532    cleanupSoupRequestOperation(handle);
    534533
     534    ResourceResponse responseCopy = d->m_response;
    535535    if (d->client()->usesAsyncCallbacks())
    536         d->client()->willSendRequestAsync(handle, newRequest, d->m_response);
     536        d->client()->willSendRequestAsync(handle, WTFMove(newRequest), WTFMove(responseCopy));
    537537    else {
    538         d->client()->willSendRequest(handle, newRequest, d->m_response);
    539         continueAfterWillSendRequest(handle, newRequest);
     538        auto request = d->client()->willSendRequest(handle, WTFMove(newRequest), WTFMove(responseCopy));
     539        continueAfterWillSendRequest(handle, WTFMove(request));
    540540    }
    541541
    … …  
    13681368}
    13691369
    1370 void ResourceHandle::continueWillSendRequest(const ResourceRequest& request)
     1370void ResourceHandle::continueWillSendRequest(ResourceRequest&& request)
    13711371{
    13721372    ASSERT(!client() || client()->usesAsyncCallbacks());
    1373     continueAfterWillSendRequest(this, request);
     1373    continueAfterWillSendRequest(this, WTFMove(request));
    13741374}
    13751375

  • trunk/Source/WebKit2/ChangeLog

    r201706 r201708  
     12016-06-06  Alex Christensen  <achristensen@webkit.org>
     2
     3        Reduce ResourceRequest copying in loading code
     4        https://bugs.webkit.org/show_bug.cgi?id=158251
     5
     6        Reviewed by Darin Adler.
     7
     8        * NetworkProcess/Downloads/DownloadManager.cpp:
     9        (WebKit::DownloadManager::continueCanAuthenticateAgainstProtectionSpace):
     10        (WebKit::DownloadManager::continueWillSendRequest):
     11        (WebKit::DownloadManager::willDecidePendingDownloadDestination):
     12        * NetworkProcess/Downloads/DownloadManager.h:
     13        * NetworkProcess/Downloads/PendingDownload.cpp:
     14        (WebKit::PendingDownload::PendingDownload):
     15        (WebKit::PendingDownload::willSendRedirectedRequest):
     16        (WebKit::PendingDownload::continueWillSendRequest):
     17        (WebKit::PendingDownload::canAuthenticateAgainstProtectionSpaceAsync):
     18        * NetworkProcess/Downloads/PendingDownload.h:
     19        * NetworkProcess/NetworkDataTask.h:
     20        (WebKit::NetworkDataTask::firstRequest):
     21        * NetworkProcess/NetworkLoad.cpp:
     22        (WebKit::NetworkLoad::cancel):
     23        (WebKit::NetworkLoad::continueWillSendRequest):
     24        (WebKit::NetworkLoad::sharedDidReceiveResponse):
     25        (WebKit::NetworkLoad::sharedWillSendRedirectedRequest):
     26        (WebKit::NetworkLoad::setPendingDownload):
     27        (WebKit::NetworkLoad::willPerformHTTPRedirection):
     28        (WebKit::NetworkLoad::didReceiveChallenge):
     29        (WebKit::NetworkLoad::didFail):
     30        (WebKit::NetworkLoad::willSendRequestAsync):
     31        * NetworkProcess/NetworkLoad.h:
     32        (WebKit::NetworkLoad::currentRequest):
     33        (WebKit::NetworkLoad::clearCurrentRequest):
     34        (WebKit::NetworkLoad::pendingDownloadID):
     35        * NetworkProcess/NetworkLoadClient.h:
     36        * NetworkProcess/NetworkProcess.cpp:
     37        (WebKit::NetworkProcess::continueCanAuthenticateAgainstProtectionSpace):
     38        (WebKit::NetworkProcess::continueWillSendRequest):
     39        (WebKit::NetworkProcess::pendingDownloadCanceled):
     40        * NetworkProcess/NetworkProcess.h:
     41        * NetworkProcess/NetworkResourceLoader.cpp:
     42        (WebKit::NetworkResourceLoader::didFailLoading):
     43        (WebKit::NetworkResourceLoader::willSendRedirectedRequest):
     44        (WebKit::NetworkResourceLoader::continueWillSendRequest):
     45        (WebKit::NetworkResourceLoader::continueDidReceiveResponse):
     46        * NetworkProcess/NetworkResourceLoader.h:
     47        * NetworkProcess/PingLoad.h:
     48        (WebKit::PingLoad::PingLoad):
     49        * NetworkProcess/cache/NetworkCacheSpeculativeLoad.cpp:
     50        (WebKit::NetworkCache::SpeculativeLoad::~SpeculativeLoad):
     51        (WebKit::NetworkCache::SpeculativeLoad::willSendRedirectedRequest):
     52        * NetworkProcess/cache/NetworkCacheSpeculativeLoad.h:
     53        * NetworkProcess/cocoa/NetworkDataTaskCocoa.mm:
     54        (WebKit::NetworkDataTask::didBecomeDownload):
     55        (WebKit::NetworkDataTask::willPerformHTTPRedirection):
     56        * WebProcess/Network/WebResourceLoader.cpp:
     57        (WebKit::WebResourceLoader::detachFromCoreLoader):
     58        (WebKit::WebResourceLoader::willSendRequest):
     59        * WebProcess/Network/WebResourceLoader.h:
     60
    1612016-06-05  Sam Weinig  <sam@webkit.org>
    262

  • trunk/Source/WebKit2/NetworkProcess/Downloads/DownloadManager.cpp

    r198893 r201708  
    8888}
    8989
    90 void DownloadManager::continueWillSendRequest(DownloadID downloadID, const WebCore::ResourceRequest& request)
     90void DownloadManager::continueWillSendRequest(DownloadID downloadID, WebCore::ResourceRequest&& request)
    9191{
    9292    auto* pendingDownload = m_pendingDownloads.get(downloadID);
    9393    ASSERT(pendingDownload);
    9494    if (pendingDownload)
    95         pendingDownload->continueWillSendRequest(request);
     95        pendingDownload->continueWillSendRequest(WTFMove(request));
    9696}
    9797

  • trunk/Source/WebKit2/NetworkProcess/Downloads/DownloadManager.h

    r198893 r201708  
    7979    std::pair<RefPtr<NetworkDataTask>, std::unique_ptr<PendingDownload>> dataTaskBecameDownloadTask(DownloadID, std::unique_ptr<Download>&&);
    8080    void continueCanAuthenticateAgainstProtectionSpace(DownloadID, bool canAuthenticate);
    81     void continueWillSendRequest(DownloadID, const WebCore::ResourceRequest&);
     81    void continueWillSendRequest(DownloadID, WebCore::ResourceRequest&&);
    8282    void willDecidePendingDownloadDestination(NetworkDataTask&, ResponseCompletionHandler);
    8383    void continueDecidePendingDownloadDestination(DownloadID, String destination, const SandboxExtension::Handle&, bool allowOverwrite);

  • trunk/Source/WebKit2/NetworkProcess/Downloads/PendingDownload.cpp

    r197050 r201708  
    4646}
    4747
    48 void PendingDownload::willSendRedirectedRequest(const WebCore::ResourceRequest&, const WebCore::ResourceRequest& redirectRequest, const WebCore::ResourceResponse& redirectResponse)
     48void PendingDownload::willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&& redirectResponse)
    4949{
    50     send(Messages::DownloadProxy::WillSendRequest(redirectRequest, redirectResponse));
     50    send(Messages::DownloadProxy::WillSendRequest(WTFMove(redirectRequest), WTFMove(redirectResponse)));
    5151};
    5252   
    53 void PendingDownload::continueWillSendRequest(const WebCore::ResourceRequest& newRequest)
     53void PendingDownload::continueWillSendRequest(WebCore::ResourceRequest&& newRequest)
    5454{
    55     m_networkLoad->continueWillSendRequest(newRequest);
     55    m_networkLoad->continueWillSendRequest(WTFMove(newRequest));
    5656}
    5757

  • trunk/Source/WebKit2/NetworkProcess/Downloads/PendingDownload.h

    r199735 r201708  
    4747    PendingDownload(const NetworkLoadParameters&, DownloadID);
    4848
    49     void continueWillSendRequest(const WebCore::ResourceRequest&);
     49    void continueWillSendRequest(WebCore::ResourceRequest&&);
    5050    void continueCanAuthenticateAgainstProtectionSpace(bool canAuthenticate);
    5151
    … …  
    5555    void canAuthenticateAgainstProtectionSpaceAsync(const WebCore::ProtectionSpace&) override;
    5656    bool isSynchronous() const override { return false; }
    57     void willSendRedirectedRequest(const WebCore::ResourceRequest&, const WebCore::ResourceRequest& redirectRequest, const WebCore::ResourceResponse& redirectResponse) override;
     57    void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&& redirectResponse) override;
    5858    ShouldContinueDidReceiveResponse didReceiveResponse(const WebCore::ResourceResponse&) override { return ShouldContinueDidReceiveResponse::No; };
    5959    void didReceiveBuffer(RefPtr<WebCore::SharedBuffer>&&, int reportedEncodedDataLength) override { };

  • trunk/Source/WebKit2/NetworkProcess/NetworkDataTask.h

    r199682 r201708  
    6969class NetworkDataTaskClient {
    7070public:
    71     virtual void willPerformHTTPRedirection(const WebCore::ResourceResponse&, const WebCore::ResourceRequest&, RedirectCompletionHandler) = 0;
     71    virtual void willPerformHTTPRedirection(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&, RedirectCompletionHandler) = 0;
    7272    virtual void didReceiveChallenge(const WebCore::AuthenticationChallenge&, ChallengeCompletionHandler) = 0;
    7373    virtual void didReceiveResponseNetworkSession(const WebCore::ResourceResponse&, ResponseCompletionHandler) = 0;
    … …  
    127127    WebCore::ResourceRequest currentRequest();
    128128    String suggestedFilename();
    129     void willPerformHTTPRedirection(const WebCore::ResourceResponse&, WebCore::ResourceRequest&&, RedirectCompletionHandler);
     129    void willPerformHTTPRedirection(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&, RedirectCompletionHandler);
    130130    void transferSandboxExtensionToDownload(Download&);
    131131    bool allowsSpecificHTTPSCertificateForHost(const WebCore::AuthenticationChallenge&);

  • trunk/Source/WebKit2/NetworkProcess/NetworkLoad.cpp

    r201593 r201708  
    106106}
    107107
    108 void NetworkLoad::continueWillSendRequest(const WebCore::ResourceRequest& newRequest)
     108void NetworkLoad::continueWillSendRequest(WebCore::ResourceRequest&& newRequest)
    109109{
    110110#if PLATFORM(COCOA)
    … …  
    129129#endif
    130130        return;
    131     } else if (m_handle)
    132         m_handle->continueWillSendRequest(m_currentRequest);
     131    } else if (m_handle) {
     132        auto currentRequestCopy = m_currentRequest;
     133        m_handle->continueWillSendRequest(WTFMove(currentRequestCopy));
     134    }
    133135
    134136#if USE(NETWORK_SESSION)
    … …  
    161163}
    162164
    163 void NetworkLoad::sharedWillSendRedirectedRequest(const ResourceRequest& request, const ResourceResponse& redirectResponse)
     165void NetworkLoad::sharedWillSendRedirectedRequest(ResourceRequest&& request, ResourceResponse&& redirectResponse)
    164166{
    165167    // We only expect to get the willSendRequest callback from ResourceHandle as the result of a redirect.
    … …  
    167169    ASSERT(RunLoop::isMain());
    168170
    169     auto oldRequest = m_currentRequest;
     171    auto oldRequest = WTFMove(m_currentRequest);
    170172    m_currentRequest = request;
    171     m_client.willSendRedirectedRequest(oldRequest, request, redirectResponse);
     173    m_client.willSendRedirectedRequest(WTFMove(oldRequest), WTFMove(request), WTFMove(redirectResponse));
    172174}
    173175
    … …  
    202204}
    203205
    204 void NetworkLoad::willPerformHTTPRedirection(const ResourceResponse& response, const ResourceRequest& request, RedirectCompletionHandler completionHandler)
     206void NetworkLoad::willPerformHTTPRedirection(ResourceResponse&& response, ResourceRequest&& request, RedirectCompletionHandler completionHandler)
    205207{
    206208    ASSERT(!m_redirectCompletionHandler);
    207209    m_redirectCompletionHandler = completionHandler;
    208     sharedWillSendRedirectedRequest(request, response);
     210    sharedWillSendRedirectedRequest(WTFMove(request), WTFMove(response));
    209211}
    210212
    … …  
    319321}
    320322
    321 void NetworkLoad::willSendRequestAsync(ResourceHandle* handle, const ResourceRequest& request, const ResourceResponse& redirectResponse)
    322 {
    323     ASSERT_UNUSED(handle, handle == m_handle);
    324     sharedWillSendRedirectedRequest(request, redirectResponse);
     323void NetworkLoad::willSendRequestAsync(ResourceHandle* handle, ResourceRequest&& request, ResourceResponse&& redirectResponse)
     324{
     325    ASSERT_UNUSED(handle, handle == m_handle);
     326    sharedWillSendRedirectedRequest(WTFMove(request), WTFMove(redirectResponse));
    325327}
    326328

  • trunk/Source/WebKit2/NetworkProcess/NetworkLoad.h

    r199599 r201708  
    5656    void clearCurrentRequest() { m_currentRequest = WebCore::ResourceRequest(); }
    5757
    58     void continueWillSendRequest(const WebCore::ResourceRequest&);
     58    void continueWillSendRequest(WebCore::ResourceRequest&&);
    5959    void continueDidReceiveResponse();
    6060
    … …  
    6666   
    6767    // NetworkDataTaskClient
    68     void willPerformHTTPRedirection(const WebCore::ResourceResponse&, const WebCore::ResourceRequest&, RedirectCompletionHandler) final;
     68    void willPerformHTTPRedirection(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&, RedirectCompletionHandler) final;
    6969    void didReceiveChallenge(const WebCore::AuthenticationChallenge&, ChallengeCompletionHandler) final;
    7070    void didReceiveResponseNetworkSession(const WebCore::ResourceResponse&, ResponseCompletionHandler) final;
    … …  
    7777#endif
    7878    // ResourceHandleClient
    79     void willSendRequestAsync(WebCore::ResourceHandle*, const WebCore::ResourceRequest&, const WebCore::ResourceResponse& redirectResponse) override;
     79    void willSendRequestAsync(WebCore::ResourceHandle*, WebCore::ResourceRequest&&, WebCore::ResourceResponse&& redirectResponse) override;
    8080    void didSendData(WebCore::ResourceHandle*, unsigned long long bytesSent, unsigned long long totalBytesToBeSent) override;
    8181    void didReceiveResponseAsync(WebCore::ResourceHandle*, const WebCore::ResourceResponse&) override;
    … …  
    118118private:
    119119    NetworkLoadClient::ShouldContinueDidReceiveResponse sharedDidReceiveResponse(const WebCore::ResourceResponse&);
    120     void sharedWillSendRedirectedRequest(const WebCore::ResourceRequest&, const WebCore::ResourceResponse&);
     120    void sharedWillSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceResponse&&);
    121121
    122122    NetworkLoadClient& m_client;

  • trunk/Source/WebKit2/NetworkProcess/NetworkLoadClient.h

    r197177 r201708  
    5151    virtual void didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent) = 0;
    5252    virtual void canAuthenticateAgainstProtectionSpaceAsync(const WebCore::ProtectionSpace&) = 0;
    53     virtual void willSendRedirectedRequest(const WebCore::ResourceRequest&, const WebCore::ResourceRequest& redirectRequest, const WebCore::ResourceResponse& redirectResponse) = 0;
     53    virtual void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&& redirectResponse) = 0;
    5454    enum class ShouldContinueDidReceiveResponse { No, Yes };
    5555    virtual ShouldContinueDidReceiveResponse didReceiveResponse(const WebCore::ResourceResponse&) = 0;

  • trunk/Source/WebKit2/NetworkProcess/NetworkProcess.cpp

    r201673 r201708  
    487487}
    488488
    489 void NetworkProcess::continueWillSendRequest(DownloadID downloadID, const WebCore::ResourceRequest& request)
    490 {
    491     downloadManager().continueWillSendRequest(downloadID, request);
     489void NetworkProcess::continueWillSendRequest(DownloadID downloadID, WebCore::ResourceRequest&& request)
     490{
     491    downloadManager().continueWillSendRequest(downloadID, WTFMove(request));
    492492}
    493493

  • trunk/Source/WebKit2/NetworkProcess/NetworkProcess.h

    r201673 r201708  
    173173#if USE(NETWORK_SESSION)
    174174    void continueCanAuthenticateAgainstProtectionSpace(DownloadID, bool canAuthenticate);
    175     void continueWillSendRequest(DownloadID, const WebCore::ResourceRequest&);
     175    void continueWillSendRequest(DownloadID, WebCore::ResourceRequest&&);
    176176    void continueDecidePendingDownloadDestination(DownloadID, String destination, const SandboxExtension::Handle& sandboxExtensionHandle, bool allowOverwrite);
    177177#endif

  • trunk/Source/WebKit2/NetworkProcess/NetworkResourceLoader.cpp

    r201444 r201708  
    411411}
    412412
    413 void NetworkResourceLoader::willSendRedirectedRequest(const ResourceRequest& request, const WebCore::ResourceRequest& redirectRequest, const ResourceResponse& redirectResponse)
     413void NetworkResourceLoader::willSendRedirectedRequest(ResourceRequest&& request, WebCore::ResourceRequest&& redirectRequest, ResourceResponse&& redirectResponse)
    414414{
    415415    ++m_redirectCount;
    … …  
    425425            overridenRequest = ResourceRequest();
    426426        }
    427         continueWillSendRequest(overridenRequest);
     427        continueWillSendRequest(WTFMove(overridenRequest));
    428428        return;
    429429    }
    … …  
    438438}
    439439
    440 void NetworkResourceLoader::continueWillSendRequest(const ResourceRequest& newRequest)
     440void NetworkResourceLoader::continueWillSendRequest(ResourceRequest&& newRequest)
    441441{
    442442    NETWORKRESOURCELOADER_LOG_ALWAYS("Following redirect of network resource: loader = %p, pageID = %llu, frameID = %llu, isMainResource = %d, isSynchronous = %d", this, static_cast<unsigned long long>(m_parameters.webPageID), static_cast<unsigned long long>(m_parameters.webFrameID), isMainResource(), isSynchronous());
    … …  
    457457
    458458    if (m_networkLoad)
    459         m_networkLoad->continueWillSendRequest(newRequest);
     459        m_networkLoad->continueWillSendRequest(WTFMove(newRequest));
    460460}
    461461

  • trunk/Source/WebKit2/NetworkProcess/NetworkResourceLoader.h

    r197728 r201708  
    7373    void continueCanAuthenticateAgainstProtectionSpace(bool);
    7474#endif
    75     void continueWillSendRequest(const WebCore::ResourceRequest& newRequest);
     75    void continueWillSendRequest(WebCore::ResourceRequest&& newRequest);
    7676
    7777    WebCore::SharedBuffer* bufferedData() { return m_bufferedData.get(); }
    … …  
    8888    void canAuthenticateAgainstProtectionSpaceAsync(const WebCore::ProtectionSpace&) override;
    8989    bool isSynchronous() const override;
    90     void willSendRedirectedRequest(const WebCore::ResourceRequest&, const WebCore::ResourceRequest& redirectRequest, const WebCore::ResourceResponse& redirectResponse) override;
     90    void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&&) override;
    9191    ShouldContinueDidReceiveResponse didReceiveResponse(const WebCore::ResourceResponse&) override;
    9292    void didReceiveBuffer(RefPtr<WebCore::SharedBuffer>&&, int reportedEncodedDataLength) override;

  • trunk/Source/WebKit2/NetworkProcess/PingLoad.h

    r198143 r201708  
    4949   
    5050private:
    51     void willPerformHTTPRedirection(const WebCore::ResourceResponse&, const WebCore::ResourceRequest&, RedirectCompletionHandler completionHandler) override
     51    void willPerformHTTPRedirection(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&, RedirectCompletionHandler completionHandler) override
    5252    {
    5353        completionHandler({ });

  • trunk/Source/WebKit2/NetworkProcess/cache/NetworkCacheSpeculativeLoad.cpp

    r201333 r201708  
    6464}
    6565
    66 void SpeculativeLoad::willSendRedirectedRequest(const ResourceRequest&, const ResourceRequest& redirectRequest, const ResourceResponse& redirectResponse)
     66void SpeculativeLoad::willSendRedirectedRequest(ResourceRequest&&, ResourceRequest&& redirectRequest, ResourceResponse&& redirectResponse)
    6767{
    6868    LOG(NetworkCacheSpeculativePreloading, "(NetworkProcess) Speculative revalidation for %s hit a redirect, aborting the load.", redirectResponse.url().string().utf8().data());

  • trunk/Source/WebKit2/NetworkProcess/cache/NetworkCacheSpeculativeLoad.h

    r199521 r201708  
    5757    void canAuthenticateAgainstProtectionSpaceAsync(const WebCore::ProtectionSpace&) override { }
    5858    bool isSynchronous() const override { return false; }
    59     void willSendRedirectedRequest(const WebCore::ResourceRequest&, const WebCore::ResourceRequest& redirectRequest, const WebCore::ResourceResponse& redirectResponse) override;
     59    void willSendRedirectedRequest(WebCore::ResourceRequest&&, WebCore::ResourceRequest&& redirectRequest, WebCore::ResourceResponse&& redirectResponse) override;
    6060    ShouldContinueDidReceiveResponse didReceiveResponse(const WebCore::ResourceResponse&) override;
    6161    void didReceiveBuffer(RefPtr<WebCore::SharedBuffer>&&, int reportedEncodedDataLength) override;

  • trunk/Source/WebKit2/NetworkProcess/cocoa/NetworkDataTaskCocoa.mm

    r201295 r201708  
    188188}
    189189
    190 void NetworkDataTask::willPerformHTTPRedirection(const WebCore::ResourceResponse& redirectResponse, WebCore::ResourceRequest&& request, RedirectCompletionHandler completionHandler)
     190void NetworkDataTask::willPerformHTTPRedirection(WebCore::ResourceResponse&& redirectResponse, WebCore::ResourceRequest&& request, RedirectCompletionHandler completionHandler)
    191191{
    192192    if (redirectResponse.httpStatusCode() == 307 || redirectResponse.httpStatusCode() == 308) {
    … …  
    233233   
    234234    if (m_client)
    235         m_client->willPerformHTTPRedirection(redirectResponse, request, completionHandler);
     235        m_client->willPerformHTTPRedirection(WTFMove(redirectResponse), WTFMove(request), completionHandler);
    236236    else {
    237237        ASSERT_NOT_REACHED();

  • trunk/Source/WebKit2/WebProcess/Network/WebResourceLoader.cpp

    r201596 r201708  
    7676}
    7777
    78 void WebResourceLoader::willSendRequest(const ResourceRequest& proposedRequest, const ResourceResponse& redirectResponse)
     78void WebResourceLoader::willSendRequest(ResourceRequest&& proposedRequest, ResourceResponse&& redirectResponse)
    7979{
    8080    LOG(Network, "(WebProcess) WebResourceLoader::willSendRequest to '%s'", proposedRequest.url().string().latin1().data());
    8181    WEBRESOURCELOADER_LOG_ALWAYS("WebResourceLoader::willSendRequest, WebResourceLoader = %p", this);
    8282
    83     RefPtr<WebResourceLoader> protect(this);
    84 
    85     ResourceRequest newRequest = proposedRequest;
    86     if (m_coreLoader->documentLoader()->applicationCacheHost()->maybeLoadFallbackForRedirect(m_coreLoader.get(), newRequest, redirectResponse))
     83    RefPtr<WebResourceLoader> protectedThis(this);
     84
     85    if (m_coreLoader->documentLoader()->applicationCacheHost()->maybeLoadFallbackForRedirect(m_coreLoader.get(), proposedRequest, redirectResponse))
    8786        return;
    8887    // FIXME: Do we need to update NetworkResourceLoader clientCredentialPolicy in case loader policy is DoNotAskClientForCrossOriginCredentials?
    89     m_coreLoader->willSendRequest(WTFMove(newRequest), redirectResponse, [protect](ResourceRequest&& request) {
    90         if (!protect->m_coreLoader)
     88    m_coreLoader->willSendRequest(WTFMove(proposedRequest), redirectResponse, [protectedThis](ResourceRequest&& request) {
     89        if (!protectedThis->m_coreLoader)
    9190            return;
    9291
    93         protect->send(Messages::NetworkResourceLoader::ContinueWillSendRequest(request));
     92        protectedThis->send(Messages::NetworkResourceLoader::ContinueWillSendRequest(request));
    9493    });
    9594}

  • trunk/Source/WebKit2/WebProcess/Network/WebResourceLoader.h

    r201596 r201708  
    7676    uint64_t messageSenderDestinationID() override;
    7777
    78     void willSendRequest(const WebCore::ResourceRequest&, const WebCore::ResourceResponse& redirectResponse);
     78    void willSendRequest(WebCore::ResourceRequest&&, WebCore::ResourceResponse&&);
    7979    void didSendData(uint64_t bytesSent, uint64_t totalBytesToBeSent);
    8080    void didReceiveResponse(const WebCore::ResourceResponse&, bool needsContinueDidReceiveResponseMessage);
Note: See TracChangeset for help on using the changeset viewer.