Changeset 224699 in webkit


Ignore:
Timestamp:
Nov 10, 2017 11:23:13 AM (6 years ago)
Author:
achristensen@apple.com
Message:

Make CachedResource::redirectReceived asynchronous
https://bugs.webkit.org/show_bug.cgi?id=179503

Reviewed by Antti Koivisto.

There were a few loops where we called redirectReceived many times in a row,
and these are replaced with a completion handler that recursively calls the next
redirectReceived or the code after the loop.

No change in behavior.

  • loader/DocumentLoader.cpp:

(WebCore::DocumentLoader::redirectReceived):

  • loader/DocumentLoader.h:

(WebCore::DocumentLoader::setLastCheckedRequest):

  • loader/DocumentThreadableLoader.cpp:

(WebCore::DocumentThreadableLoader::redirectReceived):

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

(WebCore::MediaResource::redirectReceived):

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

(WebCore::PolicyChecker::checkNavigationPolicy):

  • loader/SubresourceLoader.cpp:

(WebCore::SubresourceLoader::willSendRequestInternal):

  • loader/cache/CachedRawResource.cpp:

(WebCore::iterate):
(WebCore::CachedRawResource::didAddClient):
(WebCore::CachedRawResource::redirectReceived):

  • loader/cache/CachedRawResource.h:
  • loader/cache/CachedRawResourceClient.h:

(WebCore::CachedRawResourceClient::redirectReceived):

  • loader/cache/CachedResource.cpp:

(WebCore::CachedResource::redirectReceived):

  • loader/cache/CachedResource.h:
  • platform/graphics/PlatformMediaResourceLoader.h:

(WebCore::PlatformMediaResourceClient::redirectReceived):

  • platform/network/cocoa/WebCoreNSURLSession.mm:

(WebCore::WebCoreNSURLSessionDataTaskClient::redirectReceived):

Location:
trunk/Source/WebCore
Files:
16 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r224698 r224699  
     12017-11-10  Alex Christensen  <achristensen@webkit.org>
     2
     3        Make CachedResource::redirectReceived asynchronous
     4        https://bugs.webkit.org/show_bug.cgi?id=179503
     5
     6        Reviewed by Antti Koivisto.
     7
     8        There were a few loops where we called redirectReceived many times in a row,
     9        and these are replaced with a completion handler that recursively calls the next
     10        redirectReceived or the code after the loop.
     11
     12        No change in behavior.
     13
     14        * loader/DocumentLoader.cpp:
     15        (WebCore::DocumentLoader::redirectReceived):
     16        * loader/DocumentLoader.h:
     17        (WebCore::DocumentLoader::setLastCheckedRequest):
     18        * loader/DocumentThreadableLoader.cpp:
     19        (WebCore::DocumentThreadableLoader::redirectReceived):
     20        * loader/DocumentThreadableLoader.h:
     21        * loader/MediaResourceLoader.cpp:
     22        (WebCore::MediaResource::redirectReceived):
     23        * loader/MediaResourceLoader.h:
     24        * loader/PolicyChecker.cpp:
     25        (WebCore::PolicyChecker::checkNavigationPolicy):
     26        * loader/SubresourceLoader.cpp:
     27        (WebCore::SubresourceLoader::willSendRequestInternal):
     28        * loader/cache/CachedRawResource.cpp:
     29        (WebCore::iterate):
     30        (WebCore::CachedRawResource::didAddClient):
     31        (WebCore::CachedRawResource::redirectReceived):
     32        * loader/cache/CachedRawResource.h:
     33        * loader/cache/CachedRawResourceClient.h:
     34        (WebCore::CachedRawResourceClient::redirectReceived):
     35        * loader/cache/CachedResource.cpp:
     36        (WebCore::CachedResource::redirectReceived):
     37        * loader/cache/CachedResource.h:
     38        * platform/graphics/PlatformMediaResourceLoader.h:
     39        (WebCore::PlatformMediaResourceClient::redirectReceived):
     40        * platform/network/cocoa/WebCoreNSURLSession.mm:
     41        (WebCore::WebCoreNSURLSessionDataTaskClient::redirectReceived):
     42
    1432017-11-10  John Wilander  <wilander@apple.com>
    244
  • trunk/Source/WebCore/loader/DocumentLoader.cpp

    r223253 r224699  
    468468}
    469469
    470 void DocumentLoader::redirectReceived(CachedResource& resource, ResourceRequest& request, const ResourceResponse& redirectResponse)
     470void DocumentLoader::redirectReceived(CachedResource& resource, ResourceRequest&& request, const ResourceResponse& redirectResponse, CompletionHandler<void(ResourceRequest&&)>&& completionHandler)
    471471{
    472472    ASSERT_UNUSED(resource, &resource == m_mainResource);
    473473    willSendRequest(request, redirectResponse);
     474    completionHandler(WTFMove(request));
    474475}
    475476
  • trunk/Source/WebCore/loader/DocumentLoader.h

    r223981 r224699  
    196196    void setTriggeringAction(const NavigationAction&);
    197197    void setOverrideEncoding(const String& encoding) { m_overrideEncoding = encoding; }
    198     void setLastCheckedRequest(const ResourceRequest& request) { m_lastCheckedRequest = request; }
     198    void setLastCheckedRequest(ResourceRequest&& request) { m_lastCheckedRequest = WTFMove(request); }
    199199    const ResourceRequest& lastCheckedRequest()  { return m_lastCheckedRequest; }
    200200
     
    328328    void finishedLoading();
    329329    void mainReceivedError(const ResourceError&);
    330     WEBCORE_EXPORT void redirectReceived(CachedResource&, ResourceRequest&, const ResourceResponse&) override;
     330    WEBCORE_EXPORT void redirectReceived(CachedResource&, ResourceRequest&&, const ResourceResponse&, CompletionHandler<void(ResourceRequest&&)>&&) override;
    331331    WEBCORE_EXPORT void responseReceived(CachedResource&, const ResourceResponse&) override;
    332332    WEBCORE_EXPORT void dataReceived(CachedResource&, const char* data, int length) override;
  • trunk/Source/WebCore/loader/DocumentThreadableLoader.cpp

    r224439 r224699  
    235235}
    236236
    237 void DocumentThreadableLoader::redirectReceived(CachedResource& resource, ResourceRequest& request, const ResourceResponse& redirectResponse)
     237void DocumentThreadableLoader::redirectReceived(CachedResource& resource, ResourceRequest&& request, const ResourceResponse& redirectResponse, CompletionHandler<void(ResourceRequest&&)>&& completionHandler)
    238238{
    239239    ASSERT(m_client);
     
    249249        reportRedirectionWithBadScheme(request.url());
    250250        clearResource();
    251         return;
     251        return completionHandler(WTFMove(request));
    252252    }
    253253
     
    255255        reportContentSecurityPolicyError(redirectResponse.url());
    256256        clearResource();
    257         return;
     257        return completionHandler(WTFMove(request));
    258258    }
    259259
    260260    // Allow same origin requests to continue after allowing clients to audit the redirect.
    261261    if (isAllowedRedirect(request.url()))
    262         return;
     262        return completionHandler(WTFMove(request));
    263263
    264264    // Force any subsequent request to use these checks.
     
    277277    // But we also handle credentials here if it is restricted to SameOrigin.
    278278    if (m_options.credentials != FetchOptions::Credentials::SameOrigin && m_simpleRequest && isSimpleCrossOriginAccessRequest(request.httpMethod(), *m_originalHeaders))
    279         return;
     279        return completionHandler(WTFMove(request));
    280280
    281281    m_options.storedCredentialsPolicy = StoredCredentialsPolicy::DoNotUse;
     
    290290
    291291    makeCrossOriginAccessRequest(ResourceRequest(request));
     292    completionHandler(WTFMove(request));
    292293}
    293294
  • trunk/Source/WebCore/loader/DocumentThreadableLoader.h

    r224439 r224699  
    8484        void responseReceived(CachedResource&, const ResourceResponse&) override;
    8585        void dataReceived(CachedResource&, const char* data, int dataLength) override;
    86         void redirectReceived(CachedResource&, ResourceRequest&, const ResourceResponse&) override;
     86        void redirectReceived(CachedResource&, ResourceRequest&&, const ResourceResponse&, CompletionHandler<void(ResourceRequest&&)>&&) override;
    8787        void finishedTimingForWorkerLoad(CachedResource&, const ResourceTiming&) override;
    8888        void finishedTimingForWorkerLoad(const ResourceTiming&);
  • trunk/Source/WebCore/loader/MediaResourceLoader.cpp

    r222467 r224699  
    175175}
    176176
    177 void MediaResource::redirectReceived(CachedResource& resource, ResourceRequest& request, const ResourceResponse& response)
    178 {
    179     ASSERT_UNUSED(resource, &resource == m_resource);
    180 
    181     RefPtr<MediaResource> protectedThis(this);
    182     if (m_client)
    183         m_client->redirectReceived(*this, request, response);
     177void MediaResource::redirectReceived(CachedResource& resource, ResourceRequest&& request, const ResourceResponse& response, CompletionHandler<void(ResourceRequest&&)>&& completionHandler)
     178{
     179    ASSERT_UNUSED(resource, &resource == m_resource);
     180
     181    RefPtr<MediaResource> protectedThis(this);
     182    if (m_client)
     183        m_client->redirectReceived(*this, WTFMove(request), response, WTFMove(completionHandler));
     184    else
     185        completionHandler(WTFMove(request));
    184186}
    185187
  • trunk/Source/WebCore/loader/MediaResourceLoader.h

    r222422 r224699  
    8484    // CachedRawResourceClient
    8585    void responseReceived(CachedResource&, const ResourceResponse&) override;
    86     void redirectReceived(CachedResource&, ResourceRequest&, const ResourceResponse&) override;
     86    void redirectReceived(CachedResource&, ResourceRequest&&, const ResourceResponse&, CompletionHandler<void(ResourceRequest&&)>&&) override;
    8787    bool shouldCacheResponse(CachedResource&, const ResourceResponse&) override;
    8888    void dataSent(CachedResource&, unsigned long long, unsigned long long) override;
  • trunk/Source/WebCore/loader/PolicyChecker.cpp

    r222492 r224699  
    9494    if (equalIgnoringHeaderFields(request, loader->lastCheckedRequest()) || (!request.isNull() && request.url().isEmpty())) {
    9595        function(request, nullptr, true);
    96         loader->setLastCheckedRequest(request);
     96        loader->setLastCheckedRequest(ResourceRequest(request));
    9797        return;
    9898    }
     
    122122    }
    123123
    124     loader->setLastCheckedRequest(request);
     124    loader->setLastCheckedRequest(ResourceRequest(request));
    125125
    126126#if USE(QUICK_LOOK)
  • trunk/Source/WebCore/loader/SubresourceLoader.cpp

    r224522 r224699  
    184184    }
    185185
     186    auto continueWillSendRequest = [this, protectedThis = makeRef(*this), redirectResponse] (CompletionHandler<void(ResourceRequest&&)>&& completionHandler, ResourceRequest&& newRequest) mutable {
     187        if (newRequest.isNull() || reachedTerminalState())
     188            return completionHandler(WTFMove(newRequest));
     189
     190        ResourceLoader::willSendRequestInternal(WTFMove(newRequest), redirectResponse, [this, protectedThis = WTFMove(protectedThis), completionHandler = WTFMove(completionHandler), redirectResponse] (ResourceRequest&& request) mutable {
     191            if (reachedTerminalState())
     192                return completionHandler(WTFMove(request));
     193
     194            if (request.isNull()) {
     195                cancel();
     196                return completionHandler(WTFMove(request));
     197            }
     198
     199            if (m_resource->type() == CachedResource::MainResource && !redirectResponse.isNull())
     200                m_documentLoader->willContinueMainResourceLoadAfterRedirect(request);
     201            completionHandler(WTFMove(request));
     202        });
     203    };
     204
    186205    ASSERT(!newRequest.isNull());
    187206    if (!redirectResponse.isNull()) {
     
    235254        }
    236255        m_loadTiming.addRedirect(redirectResponse.url(), newRequest.url());
    237         m_resource->redirectReceived(newRequest, redirectResponse);
    238     }
    239 
    240     if (newRequest.isNull() || reachedTerminalState())
    241         return completionHandler(WTFMove(newRequest));
    242 
    243     ResourceLoader::willSendRequestInternal(WTFMove(newRequest), redirectResponse, [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler), redirectResponse] (ResourceRequest&& request) mutable {
    244         if (reachedTerminalState())
    245             return completionHandler(WTFMove(request));
    246        
    247         if (request.isNull()) {
    248             cancel();
    249             return completionHandler(WTFMove(request));
    250         }
    251        
    252         if (m_resource->type() == CachedResource::MainResource && !redirectResponse.isNull())
    253             m_documentLoader->willContinueMainResourceLoadAfterRedirect(request);
    254         completionHandler(WTFMove(request));
    255     });
     256        m_resource->redirectReceived(WTFMove(newRequest), redirectResponse, [completionHandler = WTFMove(completionHandler), continueWillSendRequest = WTFMove(continueWillSendRequest)] (ResourceRequest&& request) mutable {
     257            continueWillSendRequest(WTFMove(completionHandler), WTFMove(request));
     258        });
     259        return;
     260    }
     261
     262    continueWillSendRequest(WTFMove(completionHandler), WTFMove(newRequest));
    256263}
    257264
  • trunk/Source/WebCore/loader/cache/CachedRawResource.cpp

    r223091 r224699  
    3333#include "SharedBuffer.h"
    3434#include "SubresourceLoader.h"
     35#include <wtf/CompletionHandler.h>
    3536#include <wtf/text/StringView.h>
    3637
     
    116117}
    117118
     119static void iterateRedirects(CachedResourceHandle<CachedRawResource>&& handle, CachedRawResourceClient& client, Vector<std::pair<ResourceRequest, ResourceResponse>>&& redirectsInReverseOrder, CompletionHandler<void(ResourceRequest&&)>&& completionHandler)
     120{
     121    if (!handle->hasClient(client) || redirectsInReverseOrder.isEmpty())
     122        return completionHandler({ });
     123    auto redirectPair = redirectsInReverseOrder.takeLast();
     124    client.redirectReceived(*handle, WTFMove(redirectPair.first), WTFMove(redirectPair.second), [handle = WTFMove(handle), client, redirectsInReverseOrder = WTFMove(redirectsInReverseOrder), completionHandler = WTFMove(completionHandler)] (ResourceRequest&&) mutable {
     125        // Ignore the new request because we can't do anything with it.
     126        // We're just replying a redirect chain that has already happened.
     127        iterateRedirects(WTFMove(handle), client, WTFMove(redirectsInReverseOrder), WTFMove(completionHandler));
     128    });
     129}
     130
    118131void CachedRawResource::didAddClient(CachedResourceClient& c)
    119132{
    120     if (!hasClient(c))
    121         return;
    122     // The calls to the client can result in events running, potentially causing
    123     // this resource to be evicted from the cache and all clients to be removed,
    124     // so a protector is necessary.
    125     CachedResourceHandle<CachedRawResource> protectedThis(this);
    126133    CachedRawResourceClient& client = static_cast<CachedRawResourceClient&>(c);
    127134    size_t redirectCount = m_redirectChain.size();
    128     for (size_t i = 0; i < redirectCount; i++) {
    129         RedirectPair redirect = m_redirectChain[i];
    130         ResourceRequest request(redirect.m_request);
    131         client.redirectReceived(*this, request, redirect.m_redirectResponse);
    132         if (!hasClient(c))
     135    Vector<std::pair<ResourceRequest, ResourceResponse>> redirectsInReverseOrder;
     136    redirectsInReverseOrder.reserveInitialCapacity(redirectCount);
     137    for (size_t i = 0; i < redirectCount; ++i) {
     138        const auto& pair = m_redirectChain[redirectCount - i - 1];
     139        redirectsInReverseOrder.uncheckedAppend(std::make_pair(pair.m_request, pair.m_redirectResponse));
     140    }
     141    iterateRedirects(CachedResourceHandle<CachedRawResource>(this), client, WTFMove(redirectsInReverseOrder), [this, protectedThis = CachedResourceHandle<CachedRawResource>(this), client = &client] (ResourceRequest&&) mutable {
     142        if (!hasClient(*client))
    133143            return;
    134     }
    135     ASSERT(redirectCount == m_redirectChain.size());
    136 
    137     if (!m_response.isNull()) {
    138         ResourceResponse response(m_response);
    139         if (validationCompleting())
    140             response.setSource(ResourceResponse::Source::MemoryCacheAfterValidation);
    141         else {
    142             ASSERT(!validationInProgress());
    143             response.setSource(ResourceResponse::Source::MemoryCache);
     144        if (!m_response.isNull()) {
     145            ResourceResponse response(m_response);
     146            if (validationCompleting())
     147                response.setSource(ResourceResponse::Source::MemoryCacheAfterValidation);
     148            else {
     149                ASSERT(!validationInProgress());
     150                response.setSource(ResourceResponse::Source::MemoryCache);
     151            }
     152            client->responseReceived(*this, response);
    144153        }
    145         client.responseReceived(*this, response);
    146     }
    147     if (!hasClient(c))
    148         return;
    149     if (m_data)
    150         client.dataReceived(*this, m_data->data(), m_data->size());
    151     if (!hasClient(c))
    152        return;
    153     CachedResource::didAddClient(client);
     154        if (!hasClient(*client))
     155            return;
     156        if (m_data)
     157            client->dataReceived(*this, m_data->data(), m_data->size());
     158        if (!hasClient(*client))
     159            return;
     160        CachedResource::didAddClient(*client);
     161    });
    154162}
    155163
     
    160168}
    161169
    162 void CachedRawResource::redirectReceived(ResourceRequest& request, const ResourceResponse& response)
    163 {
    164     CachedResourceHandle<CachedRawResource> protectedThis(this);
    165     if (!response.isNull()) {
    166         CachedResourceClientWalker<CachedRawResourceClient> w(m_clients);
    167         while (CachedRawResourceClient* c = w.next())
    168             c->redirectReceived(*this, request, response);
     170static void iterateClients(CachedResourceClientWalker<CachedRawResourceClient>&& walker, CachedResourceHandle<CachedRawResource>&& handle, ResourceRequest&& request, std::unique_ptr<ResourceResponse>&& response, CompletionHandler<void(ResourceRequest&&)>&& completionHandler)
     171{
     172    auto client = walker.next();
     173    if (!client)
     174        return completionHandler(WTFMove(request));
     175    const ResourceResponse& responseReference = *response;
     176    client->redirectReceived(*handle, WTFMove(request), responseReference, [walker = WTFMove(walker), handle = WTFMove(handle), response = WTFMove(response), completionHandler = WTFMove(completionHandler)] (ResourceRequest&& request) mutable {
     177        iterateClients(WTFMove(walker), WTFMove(handle), WTFMove(request), WTFMove(response), WTFMove(completionHandler));
     178    });
     179}
     180
     181void CachedRawResource::redirectReceived(ResourceRequest&& request, const ResourceResponse& response, CompletionHandler<void(ResourceRequest&&)>&& completionHandler)
     182{
     183    if (response.isNull())
     184        CachedResource::redirectReceived(WTFMove(request), response, WTFMove(completionHandler));
     185    else {
    169186        m_redirectChain.append(RedirectPair(request, response));
    170     }
    171     CachedResource::redirectReceived(request, response);
     187        iterateClients(CachedResourceClientWalker<CachedRawResourceClient>(m_clients), CachedResourceHandle<CachedRawResource>(this), WTFMove(request), std::make_unique<ResourceResponse>(response), [this, protectedThis = CachedResourceHandle<CachedRawResource>(this), completionHandler = WTFMove(completionHandler), response] (ResourceRequest&& request) mutable {
     188            CachedResource::redirectReceived(WTFMove(request), response, WTFMove(completionHandler));
     189        });
     190    }
    172191}
    173192
  • trunk/Source/WebCore/loader/cache/CachedRawResource.h

    r223091 r224699  
    6363    void allClientsRemoved() override;
    6464
    65     void redirectReceived(ResourceRequest&, const ResourceResponse&) override;
     65    void redirectReceived(ResourceRequest&&, const ResourceResponse&, CompletionHandler<void(ResourceRequest&&)>&&) override;
    6666    void responseReceived(const ResourceResponse&) override;
    6767    bool shouldCacheResponse(const ResourceResponse&) override;
  • trunk/Source/WebCore/loader/cache/CachedRawResourceClient.h

    r223728 r224699  
    2424
    2525#include "CachedResourceClient.h"
     26#include <wtf/CompletionHandler.h>
    2627
    2728namespace WebCore {
     
    4243    virtual bool shouldCacheResponse(CachedResource&, const ResourceResponse&) { return true; }
    4344    virtual void dataReceived(CachedResource&, const char* /* data */, int /* length */) { }
    44     virtual void redirectReceived(CachedResource&, ResourceRequest&, const ResourceResponse&) { }
     45    virtual void redirectReceived(CachedResource&, ResourceRequest&& request, const ResourceResponse&, CompletionHandler<void(ResourceRequest&&)>&& completionHandler) { completionHandler(WTFMove(request)); }
    4546    virtual void finishedTimingForWorkerLoad(CachedResource&, const ResourceTiming&) { }
    4647#if USE(SOUP)
  • trunk/Source/WebCore/loader/cache/CachedResource.cpp

    r224522 r224699  
    454454}
    455455
    456 void CachedResource::redirectReceived(ResourceRequest&, const ResourceResponse& response)
     456void CachedResource::redirectReceived(ResourceRequest&& request, const ResourceResponse& response, CompletionHandler<void(ResourceRequest&&)>&& completionHandler)
    457457{
    458458    m_requestedFromNetworkingLayer = true;
    459459    if (response.isNull())
    460         return;
     460        return completionHandler(WTFMove(request));
    461461
    462462    updateRedirectChainStatus(m_redirectChainCacheStatus, response);
     463    completionHandler(WTFMove(request));
    463464}
    464465
  • trunk/Source/WebCore/loader/cache/CachedResource.h

    r223933 r224699  
    202202    SharedBuffer* resourceBuffer() const { return m_data.get(); }
    203203
    204     virtual void redirectReceived(ResourceRequest&, const ResourceResponse&);
     204    virtual void redirectReceived(ResourceRequest&&, const ResourceResponse&, CompletionHandler<void(ResourceRequest&&)>&&);
    205205    virtual void responseReceived(const ResourceResponse&);
    206206    virtual bool shouldCacheResponse(const ResourceResponse&) { return true; }
  • trunk/Source/WebCore/platform/graphics/PlatformMediaResourceLoader.h

    r223728 r224699  
    2828#if ENABLE(VIDEO)
    2929
     30#include <wtf/CompletionHandler.h>
    3031#include <wtf/Noncopyable.h>
    3132#include <wtf/RefCounted.h>
     
    4445
    4546    virtual void responseReceived(PlatformMediaResource&, const ResourceResponse&) { }
    46     virtual void redirectReceived(PlatformMediaResource&, ResourceRequest&, const ResourceResponse&) { }
     47    virtual void redirectReceived(PlatformMediaResource&, ResourceRequest&& request, const ResourceResponse&, CompletionHandler<void(ResourceRequest&&)>&& completionHandler) { completionHandler(WTFMove(request)); }
    4748    virtual bool shouldCacheResponse(PlatformMediaResource&, const ResourceResponse&) { return true; }
    4849    virtual void dataSent(PlatformMediaResource&, unsigned long long, unsigned long long) { }
  • trunk/Source/WebCore/platform/network/cocoa/WebCoreNSURLSession.mm

    r223238 r224699  
    3030#import "PlatformMediaResourceLoader.h"
    3131#import "SubresourceLoader.h"
     32#import <wtf/CompletionHandler.h>
    3233
    3334using namespace WebCore;
     
    350351
    351352    void responseReceived(PlatformMediaResource&, const ResourceResponse&) override;
    352     void redirectReceived(PlatformMediaResource&, ResourceRequest&, const ResourceResponse&) override;
     353    void redirectReceived(PlatformMediaResource&, ResourceRequest&&, const ResourceResponse&, CompletionHandler<void(ResourceRequest&&)>&&) override;
    353354    bool shouldCacheResponse(PlatformMediaResource&, const ResourceResponse&) override;
    354355    void dataSent(PlatformMediaResource&, unsigned long long, unsigned long long) override;
     
    382383}
    383384
    384 void WebCoreNSURLSessionDataTaskClient::redirectReceived(PlatformMediaResource& resource, ResourceRequest& request, const ResourceResponse& response)
     385void WebCoreNSURLSessionDataTaskClient::redirectReceived(PlatformMediaResource& resource, ResourceRequest&& request, const ResourceResponse& response, CompletionHandler<void(ResourceRequest&&)>&& completionHandler)
    385386{
    386387    [m_task resource:resource receivedRedirect:response request:request];
     388    completionHandler(WTFMove(request));
    387389}
    388390
Note: See TracChangeset for help on using the changeset viewer.