Changeset 224522 in webkit


Ignore:
Timestamp:
Nov 6, 2017 4:55:47 PM (6 years ago)
Author:
achristensen@apple.com
Message:

Make ResourceLoader::willSendRequestInternal asynchronous
​https://bugs.webkit.org/show_bug.cgi?id=179251

Reviewed by Andy Estes.

Source/WebCore:

ResourceLoader::willSendRequestInternal is used for redirects, which need to be asynchronous, and for the initial request.
Making it asynchronous requires making load initialization asynchronous, too.

No change in behavior. This will allow us to make more things asynchronous.

  • loader/LoaderStrategy.h:
  • loader/NetscapePlugInStreamLoader.cpp:

(WebCore::NetscapePlugInStreamLoader::create):
(WebCore::NetscapePlugInStreamLoader::init):
(WebCore::NetscapePlugInStreamLoader::willSendRequest):

  • loader/NetscapePlugInStreamLoader.h:
  • loader/ResourceLoader.cpp:

(WebCore::ResourceLoader::init):
(WebCore::ResourceLoader::willSendRequestInternal):
(WebCore::ResourceLoader::willSendRequest):
(WebCore::ResourceLoader::willSendRequestAsync):

  • loader/ResourceLoader.h:

(WebCore::ResourceLoader::startLoading):

  • loader/SubresourceLoader.cpp:

(WebCore::SubresourceLoader::create):
(WebCore::SubresourceLoader::startLoading):
(WebCore::SubresourceLoader::init):
(WebCore::SubresourceLoader::willSendRequestInternal):

  • loader/SubresourceLoader.h:
  • loader/cache/CachedResource.cpp:

(WebCore::CachedResource::load):

  • platform/network/mac/WebCoreResourceHandleAsOperationQueueDelegate.mm:

(-[WebCoreResourceHandleAsOperationQueueDelegate connection:willSendRequest:redirectResponse:]):
(-[WebCoreResourceHandleAsOperationQueueDelegate connection:willCacheResponse:]):
Calling autorelease from a non-main thread was causing crashes. This is because we need to set up an autorelease pool on that thread, which we have not done. See:
​https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/MemoryMgmt/Articles/mmAutoreleasePools.html#//apple_ref/doc/uid/20000047-1041876
I replaced the calls to RetainPtr::autorelease with RetainPtr::get. This causes us to keep the NSURLRequest and NSURLResponse alive as long as the request is being
responded to in WebKitLegacy and in El Capitan. Given the number of ResourceRequest and ResourceResponse copies we store, this shouldn't be a problem memory-wise.
This will all go away once NSURLSession is used for loading in WebKitLegacy, and this is a large step towards that.

Source/WebKit:

  • WebProcess/Network/WebLoaderStrategy.cpp:

(WebKit::WebLoaderStrategy::loadResource):
(WebKit::WebLoaderStrategy::schedulePluginStreamLoad):

  • WebProcess/Network/WebLoaderStrategy.h:
  • WebProcess/Plugins/PluginView.cpp:

(WebKit::PluginView::Stream::start):

Source/WebKitLegacy:

  • WebCoreSupport/WebResourceLoadScheduler.cpp:

(WebResourceLoadScheduler::loadResource):
(WebResourceLoadScheduler::schedulePluginStreamLoad):

  • WebCoreSupport/WebResourceLoadScheduler.h:

Source/WebKitLegacy/mac:

  • Plugins/Hosted/HostedNetscapePluginStream.mm:

(WebKit::HostedNetscapePluginStream::start):

  • Plugins/WebNetscapePluginStream.mm:

(WebNetscapePluginStream::start):

Location:
trunk/Source
Files:
21 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r224512 r224522  
     12017-11-06  Alex Christensen  <achristensen@webkit.org>
     2
     3        Make ResourceLoader::willSendRequestInternal asynchronous
     4        https://bugs.webkit.org/show_bug.cgi?id=179251
     5
     6        Reviewed by Andy Estes.
     7
     8        ResourceLoader::willSendRequestInternal is used for redirects, which need to be asynchronous, and for the initial request.
     9        Making it asynchronous requires making load initialization asynchronous, too.
     10
     11        No change in behavior.  This will allow us to make more things asynchronous.
     12
     13        * loader/LoaderStrategy.h:
     14        * loader/NetscapePlugInStreamLoader.cpp:
     15        (WebCore::NetscapePlugInStreamLoader::create):
     16        (WebCore::NetscapePlugInStreamLoader::init):
     17        (WebCore::NetscapePlugInStreamLoader::willSendRequest):
     18        * loader/NetscapePlugInStreamLoader.h:
     19        * loader/ResourceLoader.cpp:
     20        (WebCore::ResourceLoader::init):
     21        (WebCore::ResourceLoader::willSendRequestInternal):
     22        (WebCore::ResourceLoader::willSendRequest):
     23        (WebCore::ResourceLoader::willSendRequestAsync):
     24        * loader/ResourceLoader.h:
     25        (WebCore::ResourceLoader::startLoading):
     26        * loader/SubresourceLoader.cpp:
     27        (WebCore::SubresourceLoader::create):
     28        (WebCore::SubresourceLoader::startLoading):
     29        (WebCore::SubresourceLoader::init):
     30        (WebCore::SubresourceLoader::willSendRequestInternal):
     31        * loader/SubresourceLoader.h:
     32        * loader/cache/CachedResource.cpp:
     33        (WebCore::CachedResource::load):
     34        * platform/network/mac/WebCoreResourceHandleAsOperationQueueDelegate.mm:
     35        (-[WebCoreResourceHandleAsOperationQueueDelegate connection:willSendRequest:redirectResponse:]):
     36        (-[WebCoreResourceHandleAsOperationQueueDelegate connection:willCacheResponse:]):
     37        Calling autorelease from a non-main thread was causing crashes.  This is because we need to set up an autorelease pool on that thread, which we have not done.  See:
     38        https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/MemoryMgmt/Articles/mmAutoreleasePools.html#//apple_ref/doc/uid/20000047-1041876
     39        I replaced the calls to RetainPtr::autorelease with RetainPtr::get.  This causes us to keep the NSURLRequest and NSURLResponse alive as long as the request is being
     40        responded to in WebKitLegacy and in El Capitan.  Given the number of ResourceRequest and ResourceResponse copies we store, this shouldn't be a problem memory-wise.
     41        This will all go away once NSURLSession is used for loading in WebKitLegacy, and this is a large step towards that.
     42
    1432017-11-06  Wenson Hsieh  <wenson_hsieh@apple.com>
    244

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

    r222739 r224522  
    5555class WEBCORE_EXPORT LoaderStrategy {
    5656public:
    57     virtual RefPtr<SubresourceLoader> loadResource(Frame&, CachedResource&, const ResourceRequest&, const ResourceLoaderOptions&) = 0;
     57    virtual void loadResource(Frame&, CachedResource&, ResourceRequest&&, const ResourceLoaderOptions&, CompletionHandler<void(RefPtr<SubresourceLoader>&&)>&&) = 0;
    5858    virtual void loadResourceSynchronously(NetworkingContext*, unsigned long identifier, const ResourceRequest&, StoredCredentialsPolicy, ClientCredentialPolicy, ResourceError&, ResourceResponse&, Vector<char>& data) = 0;
    5959

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

    r224373 r224522  
    5555NetscapePlugInStreamLoader::~NetscapePlugInStreamLoader() = default;
    5656
    57 RefPtr<NetscapePlugInStreamLoader> NetscapePlugInStreamLoader::create(Frame& frame, NetscapePlugInStreamLoaderClient& client, const ResourceRequest& request)
     57void NetscapePlugInStreamLoader::create(Frame& frame, NetscapePlugInStreamLoaderClient& client, ResourceRequest&& request, CompletionHandler<void(RefPtr<NetscapePlugInStreamLoader>&&)>&& completionHandler)
    5858{
    59     auto loader(adoptRef(new NetscapePlugInStreamLoader(frame, client)));
    60     if (!loader->init(request))
    61         return nullptr;
    62 
    63     return loader;
     59    auto loader(adoptRef(*new NetscapePlugInStreamLoader(frame, client)));
     60    loader->init(WTFMove(request), [loader = loader.copyRef(), completionHandler = WTFMove(completionHandler)] (bool initialized) mutable {
     61        if (!initialized)
     62            return completionHandler(nullptr);
     63        completionHandler(WTFMove(loader));
     64    });
    6465}
    6566
    … …  
    7576}
    7677
    77 bool NetscapePlugInStreamLoader::init(const ResourceRequest& request)
     78void NetscapePlugInStreamLoader::init(ResourceRequest&& request, CompletionHandler<void(bool)>&& completionHandler)
    7879{
    79     if (!ResourceLoader::init(request))
    80         return false;
    81 
    82     ASSERT(!reachedTerminalState());
    83 
    84     m_documentLoader->addPlugInStreamLoader(*this);
    85     m_isInitialized = true;
    86 
    87     return true;
     80    ResourceLoader::init(WTFMove(request), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)] (bool success) mutable {
     81        if (!success)
     82            return completionHandler(false);
     83        ASSERT(!reachedTerminalState());
     84        m_documentLoader->addPlugInStreamLoader(*this);
     85        m_isInitialized = true;
     86        completionHandler(true);
     87    });
    8888}
    8989
    9090void NetscapePlugInStreamLoader::willSendRequest(ResourceRequest&& request, const ResourceResponse& redirectResponse, CompletionHandler<void(ResourceRequest&&)>&& callback)
    9191{
    92     m_client->willSendRequest(this, WTFMove(request), redirectResponse, [protectedThis = makeRef(*this), redirectResponse, callback = WTFMove(callback)](ResourceRequest request) mutable {
     92    m_client->willSendRequest(this, WTFMove(request), redirectResponse, [protectedThis = makeRef(*this), redirectResponse, callback = WTFMove(callback)] (ResourceRequest&& request) mutable {
    9393        if (!request.isNull())
    94             protectedThis->willSendRequestInternal(request, redirectResponse);
    95 
    96         callback(WTFMove(request));
     94            protectedThis->willSendRequestInternal(WTFMove(request), redirectResponse, WTFMove(callback));
     95        else
     96            callback({ });
    9797    });
    9898}

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

    r224373 r224522  
    5252class NetscapePlugInStreamLoader final : public ResourceLoader {
    5353public:
    54     WEBCORE_EXPORT static RefPtr<NetscapePlugInStreamLoader> create(Frame&, NetscapePlugInStreamLoaderClient&, const ResourceRequest&);
     54    WEBCORE_EXPORT static void create(Frame&, NetscapePlugInStreamLoaderClient&, ResourceRequest&&, CompletionHandler<void(RefPtr<NetscapePlugInStreamLoader>&&)>&&);
    5555    virtual ~NetscapePlugInStreamLoader();
    5656
    … …  
    5858
    5959private:
    60     bool init(const ResourceRequest&) override;
     60    void init(ResourceRequest&&, CompletionHandler<void(bool)>&&) override;
    6161
    6262    void willSendRequest(ResourceRequest&&, const ResourceResponse& redirectResponse, CompletionHandler<void(ResourceRequest&&)>&& callback) override;

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

    r224373 r224522  
    115115}
    116116
    117 bool ResourceLoader::init(const ResourceRequest& r)
     117void ResourceLoader::init(ResourceRequest&& clientRequest, CompletionHandler<void(bool)>&& completionHandler)
    118118{
    119119    ASSERT(!m_handle);
    … …  
    122122    ASSERT(!m_documentLoader->isSubstituteLoadPending(this));
    123123   
    124     ResourceRequest clientRequest(r);
    125 
    126124    m_loadTiming.markStartTimeAndFetchStart();
    127125
    … …  
    131129    if (!m_documentLoader->frame()) {
    132130        cancel();
    133         return false;
     131        return completionHandler(false);
    134132    }
    135133#endif
    136134   
    137135    m_defersLoading = m_options.defersLoadingPolicy == DefersLoadingPolicy::AllowDefersLoading && m_frame->page()->defersLoading();
    138     m_canAskClientForCredentials = m_options.clientCredentialPolicy == ClientCredentialPolicy::MayAskClientForCredentials && !isMixedContent(r.url());
     136    m_canAskClientForCredentials = m_options.clientCredentialPolicy == ClientCredentialPolicy::MayAskClientForCredentials && !isMixedContent(clientRequest.url());
    139137
    140138    if (m_options.securityCheck == DoSecurityCheck && !m_frame->document()->securityOrigin().canDisplay(clientRequest.url())) {
    141139        FrameLoader::reportLocalLoadFailed(m_frame.get(), clientRequest.url().string());
    142140        releaseResources();
    143         return false;
     141        return completionHandler(false);
    144142    }
    145143   
    … …  
    154152    }
    155153
    156     willSendRequestInternal(clientRequest, ResourceResponse());
     154    willSendRequestInternal(WTFMove(clientRequest), ResourceResponse(), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](ResourceRequest&& request) mutable {
    157155
    158156#if PLATFORM(IOS)
    159     // If this ResourceLoader was stopped as a result of willSendRequest, bail out.
    160     if (m_reachedTerminalState)
    161         return false;
    162 #endif
    163 
    164     if (clientRequest.isNull()) {
    165         cancel();
    166         return false;
    167     }
    168 
    169     m_originalRequest = m_request = clientRequest;
    170     return true;
     157        // If this ResourceLoader was stopped as a result of willSendRequest, bail out.
     158        if (m_reachedTerminalState)
     159            return completionHandler(false);
     160#endif
     161
     162        if (request.isNull()) {
     163            cancel();
     164            return completionHandler(false);
     165        }
     166
     167        m_request = WTFMove(request);
     168        m_originalRequest = m_request;
     169        completionHandler(true);
     170    });
    171171}
    172172
    … …  
    341341}
    342342
    343 void ResourceLoader::willSendRequestInternal(ResourceRequest& request, const ResourceResponse& redirectResponse)
     343void ResourceLoader::willSendRequestInternal(ResourceRequest&& request, const ResourceResponse& redirectResponse, CompletionHandler<void(ResourceRequest&&)>&& completionHandler)
    344344{
    345345    // Protect this in this delegate method since the additional processing can do
    … …  
    366366            applyBlockedStatusToRequest(blockedStatus, page, request);
    367367            if (blockedStatus.blockedLoad) {
    368                 request = { };
    369368                didFail(blockedByContentBlockerError());
     369                completionHandler({ });
    370370                return;
    371371            }
    … …  
    376376    if (request.isNull()) {
    377377        didFail(cannotShowURLError());
     378        completionHandler({ });
    378379        return;
    379380    }
    … …  
    385386#if PLATFORM(IOS)
    386387        // If this ResourceLoader was stopped as a result of assignIdentifierToInitialRequest, bail out
    387         if (m_reachedTerminalState)
     388        if (m_reachedTerminalState) {
     389            completionHandler(WTFMove(request));
    388390            return;
     391        }
    389392#endif
    390393
    … …  
    420423        }
    421424    }
    422 }
    423 
    424 void ResourceLoader::willSendRequest(ResourceRequest&& request, const ResourceResponse& redirectResponse, CompletionHandler<void(ResourceRequest&&)>&& callback)
    425 {
    426     willSendRequestInternal(request, redirectResponse);
    427     callback(WTFMove(request));
     425    completionHandler(WTFMove(request));
     426}
     427
     428void ResourceLoader::willSendRequest(ResourceRequest&& request, const ResourceResponse& redirectResponse, CompletionHandler<void(ResourceRequest&&)>&& completionHandler)
     429{
     430    willSendRequestInternal(WTFMove(request), redirectResponse, WTFMove(completionHandler));
    428431}
    429432
    … …  
    647650        return;
    648651    }
    649     willSendRequestInternal(request, redirectResponse);
    650     completionHandler(WTFMove(request));
     652    willSendRequestInternal(WTFMove(request), redirectResponse, WTFMove(completionHandler));
    651653}
    652654

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

    r224373 r224522  
    6161    WEBCORE_EXPORT void cancel();
    6262
    63     virtual bool init(const ResourceRequest&);
     63    virtual void init(ResourceRequest&&, CompletionHandler<void(bool)>&&);
    6464
    6565    void deliverResponseAndData(const ResourceResponse&, RefPtr<SharedBuffer>&&);
    6666
    6767#if PLATFORM(IOS)
    68     virtual bool startLoading()
     68    virtual void startLoading()
    6969    {
    7070        start();
    71         return true;
    7271    }
    7372
    … …  
    166165#endif
    167166
    168     virtual void willSendRequestInternal(ResourceRequest&, const ResourceResponse& redirectResponse);
     167    virtual void willSendRequestInternal(ResourceRequest&&, const ResourceResponse& redirectResponse, CompletionHandler<void(ResourceRequest&&)>&&);
    169168
    170169    RefPtr<ResourceHandle> m_handle;

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

    r224369 r224522  
    4646#include "ResourceTiming.h"
    4747#include "RuntimeEnabledFeatures.h"
     48#include <wtf/CompletionHandler.h>
    4849#include <wtf/Ref.h>
    4950#include <wtf/RefCountedLeakCounter.h>
    … …  
    103104}
    104105
    105 RefPtr<SubresourceLoader> SubresourceLoader::create(Frame& frame, CachedResource& resource, const ResourceRequest& request, const ResourceLoaderOptions& options)
    106 {
    107     RefPtr<SubresourceLoader> subloader(adoptRef(new SubresourceLoader(frame, resource, options)));
     106void SubresourceLoader::create(Frame& frame, CachedResource& resource, ResourceRequest&& request, const ResourceLoaderOptions& options, CompletionHandler<void(RefPtr<SubresourceLoader>&&)>&& completionHandler)
     107{
     108    auto subloader(adoptRef(*new SubresourceLoader(frame, resource, options)));
    108109#if PLATFORM(IOS)
    109110    if (!IOSApplication::isWebProcess()) {
    … …  
    112113        // FIXME: This should be fixed for all ports in <https://bugs.webkit.org/show_bug.cgi?id=56647>.
    113114        subloader->m_iOSOriginalRequest = request;
    114         return subloader;
    115     }
    116 #endif
    117     if (!subloader->init(request))
    118         return nullptr;
    119     return subloader;
     115        return completionHandler(WTFMove(subloader));
     116    }
     117#endif
     118    subloader->init(WTFMove(request), [subloader = subloader.copyRef(), completionHandler = WTFMove(completionHandler)] (bool initialized) mutable {
     119        if (!initialized)
     120            return completionHandler(nullptr);
     121        completionHandler(WTFMove(subloader));
     122    });
    120123}
    121124   
    122125#if PLATFORM(IOS)
    123 bool SubresourceLoader::startLoading()
    124 {
     126void SubresourceLoader::startLoading()
     127{
     128    // FIXME: this should probably be removed.
    125129    ASSERT(!IOSApplication::isWebProcess());
    126     if (!init(m_iOSOriginalRequest))
    127         return false;
    128     m_iOSOriginalRequest = ResourceRequest();
    129     start();
     130    init(ResourceRequest(m_iOSOriginalRequest), [this, protectedThis = makeRef(*this)] (bool success) {
     131        if (!success)
     132            return;
     133        m_iOSOriginalRequest = ResourceRequest();
     134        start();
     135    });
     136}
     137#endif
     138
     139CachedResource* SubresourceLoader::cachedResource()
     140{
     141    return m_resource;
     142}
     143
     144void SubresourceLoader::cancelIfNotFinishing()
     145{
     146    if (m_state != Initialized)
     147        return;
     148
     149    ResourceLoader::cancel();
     150}
     151
     152void SubresourceLoader::init(ResourceRequest&& request, CompletionHandler<void(bool)>&& completionHandler)
     153{
     154    ResourceLoader::init(WTFMove(request), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)] (bool initialized) mutable {
     155        if (!initialized)
     156            return completionHandler(false);
     157        ASSERT(!reachedTerminalState());
     158        m_state = Initialized;
     159        m_documentLoader->addSubresourceLoader(this);
     160        m_origin = m_resource->origin();
     161        completionHandler(true);
     162    });
     163}
     164
     165bool SubresourceLoader::isSubresourceLoader()
     166{
    130167    return true;
    131168}
    132 #endif
    133 
    134 CachedResource* SubresourceLoader::cachedResource()
    135 {
    136     return m_resource;
    137 }
    138 
    139 void SubresourceLoader::cancelIfNotFinishing()
    140 {
    141     if (m_state != Initialized)
    142         return;
    143 
    144     ResourceLoader::cancel();
    145 }
    146 
    147 bool SubresourceLoader::init(const ResourceRequest& request)
    148 {
    149     if (!ResourceLoader::init(request))
    150         return false;
    151 
    152     ASSERT(!reachedTerminalState());
    153     m_state = Initialized;
    154     m_documentLoader->addSubresourceLoader(this);
    155 
    156     m_origin = m_resource->origin();
    157 
    158     return true;
    159 }
    160 
    161 bool SubresourceLoader::isSubresourceLoader()
    162 {
    163     return true;
    164 }
    165 
    166 void SubresourceLoader::willSendRequestInternal(ResourceRequest& newRequest, const ResourceResponse& redirectResponse)
     169
     170void SubresourceLoader::willSendRequestInternal(ResourceRequest&& newRequest, const ResourceResponse& redirectResponse, CompletionHandler<void(ResourceRequest&&)>&& completionHandler)
    167171{
    168172    // Store the previous URL because the call to ResourceLoader::willSendRequest will modify it.
    … …  
    172176    if (!newRequest.url().isValid()) {
    173177        cancel(cannotShowURLError());
    174         return;
     178        return completionHandler(WTFMove(newRequest));
    175179    }
    176180
    … …  
    185189            if (options().redirect == FetchOptions::Redirect::Error) {
    186190                cancel();
    187                 return;
     191                return completionHandler(WTFMove(newRequest));
    188192            }
    189193
    … …  
    195199            NetworkLoadMetrics emptyMetrics;
    196200            didFinishLoading(emptyMetrics);
    197             return;
     201            return completionHandler(WTFMove(newRequest));
    198202        } else if (m_redirectCount++ >= options().maxRedirectCount) {
    199203            cancel(ResourceError(String(), 0, request().url(), ASCIILiteral("Too many redirections"), ResourceError::Type::General));
    200             return;
     204            return completionHandler(WTFMove(newRequest));
    201205        }
    202206
    … …  
    214218        if (!m_documentLoader->cachedResourceLoader().updateRequestAfterRedirection(m_resource->type(), newRequest, options())) {
    215219            cancel();
    216             return;
     220            return completionHandler(WTFMove(newRequest));
    217221        }
    218222
    … …  
    223227                m_frame->document()->addConsoleMessage(MessageSource::Security, MessageLevel::Error, errorMessage);
    224228            cancel(ResourceError(String(), 0, request().url(), errorMessage, ResourceError::Type::AccessControl));
    225             return;
     229            return completionHandler(WTFMove(newRequest));
    226230        }
    227231
    228232        if (m_resource->isImage() && m_documentLoader->cachedResourceLoader().shouldDeferImageLoad(newRequest.url())) {
    229233            cancel();
    230             return;
     234            return completionHandler(WTFMove(newRequest));
    231235        }
    232236        m_loadTiming.addRedirect(redirectResponse.url(), newRequest.url());
    … …  
    235239
    236240    if (newRequest.isNull() || reachedTerminalState())
    237         return;
    238 
    239     ResourceLoader::willSendRequestInternal(newRequest, redirectResponse);
    240 
    241     if (reachedTerminalState())
    242         return;
    243 
    244     if (newRequest.isNull()) {
    245         cancel();
    246         return;
    247     }
    248 
    249     if (m_resource->type() == CachedResource::MainResource && !redirectResponse.isNull())
    250         m_documentLoader->willContinueMainResourceLoadAfterRedirect(newRequest);
     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    });
    251256}
    252257

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

    r219954 r224522  
    4343class SubresourceLoader final : public ResourceLoader {
    4444public:
    45     WEBCORE_EXPORT static RefPtr<SubresourceLoader> create(Frame&, CachedResource&, const ResourceRequest&, const ResourceLoaderOptions&);
     45    WEBCORE_EXPORT static void create(Frame&, CachedResource&, ResourceRequest&&, const ResourceLoaderOptions&, CompletionHandler<void(RefPtr<SubresourceLoader>&&)>&&);
    4646
    4747    virtual ~SubresourceLoader();
    … …  
    5353    SecurityOrigin* origin() { return m_origin.get(); }
    5454#if PLATFORM(IOS)
    55     bool startLoading() override;
     55    void startLoading() override;
    5656
    5757    // FIXME: What is an "iOS" original request? Why is it necessary?
    … …  
    6464    SubresourceLoader(Frame&, CachedResource&, const ResourceLoaderOptions&);
    6565
    66     bool init(const ResourceRequest&) override;
     66    void init(ResourceRequest&&, CompletionHandler<void(bool)>&&) override;
    6767
    68     void willSendRequestInternal(ResourceRequest&, const ResourceResponse& redirectResponse) override;
     68    void willSendRequestInternal(ResourceRequest&&, const ResourceResponse& redirectResponse, CompletionHandler<void(ResourceRequest&&)>&&) override;
    6969    void didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent) override;
    7070    void didReceiveResponse(const ResourceResponse&) override;

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

    r223933 r224522  
    4949#include "SubresourceLoader.h"
    5050#include "URL.h"
     51#include <wtf/CompletionHandler.h>
    5152#include <wtf/CurrentTime.h>
    5253#include <wtf/MathExtras.h>
    … …  
    294295    }
    295296
    296     m_loader = platformStrategies()->loaderStrategy()->loadResource(frame, *this, request, m_options);
    297     if (!m_loader) {
    298         RELEASE_LOG_IF_ALLOWED("load: Unable to create SubresourceLoader (frame = %p)", &frame);
    299         failBeforeStarting();
    300         return;
    301     }
    302 
    303     m_status = Pending;
     297    platformStrategies()->loaderStrategy()->loadResource(frame, *this, WTFMove(request), m_options, [this, protectedThis = CachedResourceHandle<CachedResource>(this), frame = makeRef(frame), loggingAllowed = cachedResourceLoader.isAlwaysOnLoggingAllowed()] (RefPtr<SubresourceLoader>&& loader) {
     298        m_loader = WTFMove(loader);
     299        if (!m_loader) {
     300            RELEASE_LOG_IF(loggingAllowed, Network, "%p - CachedResource::load: Unable to create SubresourceLoader (frame = %p)", this, frame.ptr());
     301            failBeforeStarting();
     302            return;
     303        }
     304        m_status = Pending;
     305    });
    304306}
    305307

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

    r224373 r224522  
    129129
    130130    dispatch_semaphore_wait(m_semaphore, DISPATCH_TIME_FOREVER);
    131     return m_requestResult.autorelease();
     131    return m_requestResult.get();
    132132}
    133133
    … …  
    335335
    336336    dispatch_semaphore_wait(m_semaphore, DISPATCH_TIME_FOREVER);
    337     return m_cachedResponseResult.autorelease();
     337    return m_cachedResponseResult.get();
    338338}
    339339

  • trunk/Source/WebKit/ChangeLog

    r224512 r224522  
     12017-11-06  Alex Christensen  <achristensen@webkit.org>
     2
     3        Make ResourceLoader::willSendRequestInternal asynchronous
     4        https://bugs.webkit.org/show_bug.cgi?id=179251
     5
     6        Reviewed by Andy Estes.
     7
     8        * WebProcess/Network/WebLoaderStrategy.cpp:
     9        (WebKit::WebLoaderStrategy::loadResource):
     10        (WebKit::WebLoaderStrategy::schedulePluginStreamLoad):
     11        * WebProcess/Network/WebLoaderStrategy.h:
     12        * WebProcess/Plugins/PluginView.cpp:
     13        (WebKit::PluginView::Stream::start):
     14
    1152017-11-06  Wenson Hsieh  <wenson_hsieh@apple.com>
    216

  • trunk/Source/WebKit/WebProcess/Network/WebLoaderStrategy.cpp

    r224439 r224522  
    6666#include <WebCore/UserContentProvider.h>
    6767#include <pal/SessionID.h>
     68#include <wtf/CompletionHandler.h>
    6869#include <wtf/text/CString.h>
    6970
    … …  
    8889}
    8990
    90 RefPtr<SubresourceLoader> WebLoaderStrategy::loadResource(Frame& frame, CachedResource& resource, const ResourceRequest& request, const ResourceLoaderOptions& options)
    91 {
    92     RefPtr<SubresourceLoader> loader = SubresourceLoader::create(frame, resource, request, options);
    93     if (loader)
    94         scheduleLoad(*loader, &resource, frame.document()->referrerPolicy() == ReferrerPolicy::NoReferrerWhenDowngrade);
    95     else
    96         RELEASE_LOG_IF_ALLOWED(frame, "loadResource: Unable to create SubresourceLoader (frame = %p", &frame);
    97     return loader;
    98 }
    99 
    100 RefPtr<NetscapePlugInStreamLoader> WebLoaderStrategy::schedulePluginStreamLoad(Frame& frame, NetscapePlugInStreamLoaderClient& client, const ResourceRequest& request)
    101 {
    102     RefPtr<NetscapePlugInStreamLoader> loader = NetscapePlugInStreamLoader::create(frame, client, request);
    103     if (loader)
    104         scheduleLoad(*loader, 0, frame.document()->referrerPolicy() == ReferrerPolicy::NoReferrerWhenDowngrade);
    105     return loader;
     91void WebLoaderStrategy::loadResource(Frame& frame, CachedResource& resource, ResourceRequest&& request, const ResourceLoaderOptions& options, CompletionHandler<void(RefPtr<SubresourceLoader>&&)>&& completionHandler)
     92{
     93    SubresourceLoader::create(frame, resource, WTFMove(request), options, [this, completionHandler = WTFMove(completionHandler), resource = CachedResourceHandle<CachedResource>(&resource), frame = makeRef(frame)] (RefPtr<SubresourceLoader>&& loader) mutable {
     94        if (loader)
     95            scheduleLoad(*loader, resource.get(), frame->document()->referrerPolicy() == ReferrerPolicy::NoReferrerWhenDowngrade);
     96        else
     97            RELEASE_LOG_IF_ALLOWED(frame.get(), "loadResource: Unable to create SubresourceLoader (frame = %p", &frame);
     98        completionHandler(WTFMove(loader));
     99    });
     100}
     101
     102void WebLoaderStrategy::schedulePluginStreamLoad(Frame& frame, NetscapePlugInStreamLoaderClient& client, ResourceRequest&& request, CompletionHandler<void(RefPtr<NetscapePlugInStreamLoader>&&)>&& completionHandler)
     103{
     104    NetscapePlugInStreamLoader::create(frame, client, WTFMove(request), [this, completionHandler = WTFMove(completionHandler), frame = makeRef(frame)] (RefPtr<NetscapePlugInStreamLoader>&& loader) mutable {
     105        if (loader)
     106            scheduleLoad(*loader, 0, frame->document()->referrerPolicy() == ReferrerPolicy::NoReferrerWhenDowngrade);
     107        completionHandler(WTFMove(loader));
     108    });
    106109}
    107110

  • trunk/Source/WebKit/WebProcess/Network/WebLoaderStrategy.h

    r223981 r224522  
    4848    ~WebLoaderStrategy() final;
    4949   
    50     RefPtr<WebCore::SubresourceLoader> loadResource(WebCore::Frame&, WebCore::CachedResource&, const WebCore::ResourceRequest&, const WebCore::ResourceLoaderOptions&) final;
     50    void loadResource(WebCore::Frame&, WebCore::CachedResource&, WebCore::ResourceRequest&&, const WebCore::ResourceLoaderOptions&, CompletionHandler<void(RefPtr<WebCore::SubresourceLoader>&&)>&&) final;
    5151    void loadResourceSynchronously(WebCore::NetworkingContext*, unsigned long resourceLoadIdentifier, const WebCore::ResourceRequest&, WebCore::StoredCredentialsPolicy, WebCore::ClientCredentialPolicy, WebCore::ResourceError&, WebCore::ResourceResponse&, Vector<char>& data) final;
    5252
    … …  
    7171
    7272    WebResourceLoader* webResourceLoaderForIdentifier(ResourceLoadIdentifier identifier) const { return m_webResourceLoaders.get(identifier); }
    73     RefPtr<WebCore::NetscapePlugInStreamLoader> schedulePluginStreamLoad(WebCore::Frame&, WebCore::NetscapePlugInStreamLoaderClient&, const WebCore::ResourceRequest&);
     73    void schedulePluginStreamLoad(WebCore::Frame&, WebCore::NetscapePlugInStreamLoaderClient&, WebCore::ResourceRequest&&, CompletionHandler<void(RefPtr<WebCore::NetscapePlugInStreamLoader>&&)>&&);
    7474
    7575    void networkProcessCrashed();

  • trunk/Source/WebKit/WebProcess/Plugins/PluginView.cpp

    r224387 r224522  
    168168    ASSERT(frame);
    169169
    170     m_loader = WebProcess::singleton().webLoaderStrategy().schedulePluginStreamLoad(*frame, *this, m_request);
     170    WebProcess::singleton().webLoaderStrategy().schedulePluginStreamLoad(*frame, *this, ResourceRequest {m_request}, [this, protectedThis = makeRef(*this)](RefPtr<NetscapePlugInStreamLoader>&& loader) {
     171        m_loader = WTFMove(loader);
     172    });
    171173}
    172174

  • trunk/Source/WebKitLegacy/ChangeLog

    r224371 r224522  
     12017-11-06  Alex Christensen  <achristensen@webkit.org>
     2
     3        Make ResourceLoader::willSendRequestInternal asynchronous
     4        https://bugs.webkit.org/show_bug.cgi?id=179251
     5
     6        Reviewed by Andy Estes.
     7
     8        * WebCoreSupport/WebResourceLoadScheduler.cpp:
     9        (WebResourceLoadScheduler::loadResource):
     10        (WebResourceLoadScheduler::schedulePluginStreamLoad):
     11        * WebCoreSupport/WebResourceLoadScheduler.h:
     12
    1132017-11-02  Christopher Reid  <chris.reid@sony.com>
    214

  • trunk/Source/WebKitLegacy/WebCoreSupport/WebResourceLoadScheduler.cpp

    r224267 r224522  
    8989}
    9090
    91 RefPtr<SubresourceLoader> WebResourceLoadScheduler::loadResource(Frame& frame, CachedResource& resource, const ResourceRequest& request, const ResourceLoaderOptions& options)
    92 {
    93     RefPtr<SubresourceLoader> loader = SubresourceLoader::create(frame, resource, request, options);
    94     if (loader)
    95         scheduleLoad(loader.get());
    96 #if PLATFORM(IOS)
    97     // Since we defer loader initialization until scheduling on iOS, the frame
    98     // load delegate that would be called in SubresourceLoader::create() on
    99     // other ports might be called in scheduleLoad() instead. Our contract to
    100     // callers of this method is that a null loader is returned if the load was
    101     // cancelled by a frame load delegate.
    102     if (!loader || loader->reachedTerminalState())
    103         return nullptr;
    104 #endif
    105     return loader;
     91void WebResourceLoadScheduler::loadResource(Frame& frame, CachedResource& resource, ResourceRequest&& request, const ResourceLoaderOptions& options, CompletionHandler<void(RefPtr<WebCore::SubresourceLoader>&&)>&& completionHandler)
     92{
     93    SubresourceLoader::create(frame, resource, WTFMove(request), options, [this, completionHandler = WTFMove(completionHandler)] (RefPtr<WebCore::SubresourceLoader>&& loader) mutable {
     94        if (loader)
     95            scheduleLoad(loader.get());
     96#if PLATFORM(IOS)
     97        // Since we defer loader initialization until scheduling on iOS, the frame
     98        // load delegate that would be called in SubresourceLoader::create() on
     99        // other ports might be called in scheduleLoad() instead. Our contract to
     100        // callers of this method is that a null loader is returned if the load was
     101        // cancelled by a frame load delegate.
     102        if (!loader || loader->reachedTerminalState())
     103            return completionHandler(nullptr);
     104#endif
     105        completionHandler(WTFMove(loader));
     106    });
    106107}
    107108
    … …  
    111112}
    112113
    113 RefPtr<NetscapePlugInStreamLoader> WebResourceLoadScheduler::schedulePluginStreamLoad(Frame& frame, NetscapePlugInStreamLoaderClient& client, const ResourceRequest& request)
    114 {
    115     RefPtr<NetscapePlugInStreamLoader> loader = NetscapePlugInStreamLoader::create(frame, client, request);
    116     if (loader)
    117         scheduleLoad(loader.get());
    118     return loader;
     114void WebResourceLoadScheduler::schedulePluginStreamLoad(Frame& frame, NetscapePlugInStreamLoaderClient& client, ResourceRequest&& request, CompletionHandler<void(RefPtr<WebCore::NetscapePlugInStreamLoader>&&)>&& completionHandler)
     115{
     116    NetscapePlugInStreamLoader::create(frame, client, WTFMove(request), [this, completionHandler = WTFMove(completionHandler)] (RefPtr<WebCore::NetscapePlugInStreamLoader>&& loader) mutable {
     117        if (loader)
     118            scheduleLoad(loader.get());
     119        completionHandler(WTFMove(loader));
     120    });
    119121}
    120122

  • trunk/Source/WebKitLegacy/WebCoreSupport/WebResourceLoadScheduler.h

    r222673 r224522  
    5050    WebResourceLoadScheduler();
    5151
    52     RefPtr<WebCore::SubresourceLoader> loadResource(WebCore::Frame&, WebCore::CachedResource&, const WebCore::ResourceRequest&, const WebCore::ResourceLoaderOptions&) final;
     52    void loadResource(WebCore::Frame&, WebCore::CachedResource&, WebCore::ResourceRequest&&, const WebCore::ResourceLoaderOptions&, CompletionHandler<void(RefPtr<WebCore::SubresourceLoader>&&)>&&) final;
    5353    void loadResourceSynchronously(WebCore::NetworkingContext*, unsigned long, const WebCore::ResourceRequest&, WebCore::StoredCredentialsPolicy, WebCore::ClientCredentialPolicy, WebCore::ResourceError&, WebCore::ResourceResponse&, Vector<char>&) final;
    5454    void remove(WebCore::ResourceLoader*) final;
    … …  
    7171    void setSerialLoadingEnabled(bool b) { m_isSerialLoadingEnabled = b; }
    7272
    73     RefPtr<WebCore::NetscapePlugInStreamLoader> schedulePluginStreamLoad(WebCore::Frame&, WebCore::NetscapePlugInStreamLoaderClient&, const WebCore::ResourceRequest&);
     73    void schedulePluginStreamLoad(WebCore::Frame&, WebCore::NetscapePlugInStreamLoaderClient&, WebCore::ResourceRequest&&, CompletionHandler<void(RefPtr<WebCore::NetscapePlugInStreamLoader>&&)>&&);
    7474
    7575protected:

  • trunk/Source/WebKitLegacy/mac/ChangeLog

    r224459 r224522  
     12017-11-06  Alex Christensen  <achristensen@webkit.org>
     2
     3        Make ResourceLoader::willSendRequestInternal asynchronous
     4        https://bugs.webkit.org/show_bug.cgi?id=179251
     5
     6        Reviewed by Andy Estes.
     7
     8        * Plugins/Hosted/HostedNetscapePluginStream.mm:
     9        (WebKit::HostedNetscapePluginStream::start):
     10        * Plugins/WebNetscapePluginStream.mm:
     11        (WebNetscapePluginStream::start):
     12
    1132017-11-01  Darin Adler  <darin@apple.com>
    214

  • trunk/Source/WebKitLegacy/mac/Plugins/Hosted/HostedNetscapePluginStream.mm

    r224373 r224522  
    224224    ASSERT(!m_loader);
    225225
    226     m_loader = webResourceLoadScheduler().schedulePluginStreamLoad(*core([m_instance->pluginView() webFrame]), *this, m_request.get());
     226    webResourceLoadScheduler().schedulePluginStreamLoad(*core([m_instance->pluginView() webFrame]), *this, m_request.get(), [this, protectedThis = makeRef(*this)] (RefPtr<WebCore::NetscapePlugInStreamLoader>&& loader) {
     227        m_loader = WTFMove(loader);
     228    });
    227229}
    228230

  • trunk/Source/WebKitLegacy/mac/Plugins/WebNetscapePluginStream.mm

    r224373 r224522  
    292292    ASSERT(!m_loader);
    293293
    294     m_loader = webResourceLoadScheduler().schedulePluginStreamLoad(*core([m_pluginView.get() webFrame]), *this, m_request.get());
     294    webResourceLoadScheduler().schedulePluginStreamLoad(*core([m_pluginView.get() webFrame]), *this, m_request.get(), [this, protectedThis = makeRef(*this)] (RefPtr<WebCore::NetscapePlugInStreamLoader>&& loader) {
     295        m_loader = WTFMove(loader);
     296    });
    295297}
    296298

  • trunk/Source/WebKitLegacy/win/Plugins/PluginStream.cpp

    r224373 r224522  
    9999    ASSERT(!m_loadManually);
    100100    ASSERT(m_frame);
    101     m_loader = webResourceLoadScheduler().schedulePluginStreamLoad(*m_frame, *this, m_resourceRequest);
     101    webResourceLoadScheduler().schedulePluginStreamLoad(*m_frame, *this, ResourceRequest(m_resourceRequest), [this, protectedThis = makeRef(*this)] (RefPtr<WebCore::NetscapePlugInStreamLoader>&& loader) {
     102        m_loader = WTFMove(loader);
     103    });
    102104}
    103105
Note: See TracChangeset for help on using the changeset viewer.