Changeset 203079 in webkit


Ignore:
Timestamp:
Jul 11, 2016, 1:11:03 PM (9 years ago)
Author:
Ryan Haddad
Message:

Unreviewed, rolling out r203064.
​https://bugs.webkit.org/show_bug.cgi?id=159642

This change causes LayoutTest crashes on WK1 ASan (Requested
by ryanhaddad on #webkit).

Reverted changeset:

"Use refs for ResourceLoaders"
​https://bugs.webkit.org/show_bug.cgi?id=159592
​http://trac.webkit.org/changeset/203064

Patch by Commit Queue <​commit-queue@webkit.org> on 2016-07-11

Location:
trunk/Source
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r203077 r203079  
     12016-07-11  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r203064.
     4        https://bugs.webkit.org/show_bug.cgi?id=159642
     5
     6        This change causes LayoutTest crashes on WK1 ASan (Requested
     7        by ryanhaddad on #webkit).
     8
     9        Reverted changeset:
     10
     11        "Use refs for ResourceLoaders"
     12        https://bugs.webkit.org/show_bug.cgi?id=159592
     13        http://trac.webkit.org/changeset/203064
     14
    1152016-07-11  Brent Fulgham  <bfulgham@apple.com>
    216

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

    r203064 r203079  
    5252    virtual void loadResourceSynchronously(NetworkingContext*, unsigned long identifier, const ResourceRequest&, StoredCredentials, ClientCredentialPolicy, ResourceError&, ResourceResponse&, Vector<char>& data) = 0;
    5353
    54     virtual void remove(ResourceLoader&) = 0;
    55     virtual void setDefersLoading(ResourceLoader&, bool) = 0;
    56     virtual void crossOriginRedirectReceived(ResourceLoader&, const URL& redirectURL) = 0;
     54    virtual void remove(ResourceLoader*) = 0;
     55    virtual void setDefersLoading(ResourceLoader*, bool) = 0;
     56    virtual void crossOriginRedirectReceived(ResourceLoader*, const URL& redirectURL) = 0;
    5757
    5858    virtual void servePendingRequests(ResourceLoadPriority minimumPriority = ResourceLoadPriority::VeryLow) = 0;

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

    r203064 r203079  
    7474void ResourceLoader::finishNetworkLoad()
    7575{
    76     platformStrategies()->loaderStrategy()->remove(*this);
     76    platformStrategies()->loaderStrategy()->remove(this);
    7777
    7878    if (m_handle) {
    … …  
    224224    }
    225225
    226     platformStrategies()->loaderStrategy()->setDefersLoading(*this, defers);
     226    platformStrategies()->loaderStrategy()->setDefersLoading(this, defers);
    227227}
    228228
    … …  
    280280{
    281281    ASSERT(!m_documentLoader->isSubstituteLoadPending(this));
    282     platformStrategies()->loaderStrategy()->remove(*this);
     282    platformStrategies()->loaderStrategy()->remove(this);
    283283    if (m_handle)
    284284        m_handle->cancel();
    … …  
    368368    bool isRedirect = !redirectResponse.isNull();
    369369    if (isRedirect)
    370         platformStrategies()->loaderStrategy()->crossOriginRedirectReceived(*this, request.url());
     370        platformStrategies()->loaderStrategy()->crossOriginRedirectReceived(this, request.url());
    371371
    372372    m_request = request;

  • trunk/Source/WebKit/ChangeLog

    r203064 r203079  
     12016-07-11  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r203064.
     4        https://bugs.webkit.org/show_bug.cgi?id=159642
     5
     6        This change causes LayoutTest crashes on WK1 ASan (Requested
     7        by ryanhaddad on #webkit).
     8
     9        Reverted changeset:
     10
     11        "Use refs for ResourceLoaders"
     12        https://bugs.webkit.org/show_bug.cgi?id=159592
     13        http://trac.webkit.org/changeset/203064
     14
    1152016-07-08  Alex Christensen  <achristensen@webkit.org>
    216

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

    r203064 r203079  
    6868{
    6969    if (!url.protocolIsInHTTPFamily())
    70         return &m_nonHTTPProtocolHost;
     70        return m_nonHTTPProtocolHost;
    7171
    7272    m_hosts.checkConsistency();
    … …  
    7474    HostInformation* host = m_hosts.get(hostName);
    7575    if (!host && createHostPolicy == CreateIfNotFound) {
    76         auto newHost = std::make_unique<HostInformation>(hostName, maxRequestsInFlightPerHost);
    77         host = newHost.get();
    78         m_hosts.add(hostName, WTFMove(newHost));
     76        host = new HostInformation(hostName, maxRequestsInFlightPerHost);
     77        m_hosts.add(hostName, host);
    7978    }
    8079    return host;
    … …  
    8281
    8382WebResourceLoadScheduler::WebResourceLoadScheduler()
    84     : m_nonHTTPProtocolHost(String(), maxRequestsInFlightForNonHTTPProtocols)
     83    : m_nonHTTPProtocolHost(new HostInformation(String(), maxRequestsInFlightForNonHTTPProtocols))
    8584    , m_requestTimer(*this, &WebResourceLoadScheduler::requestTimerFired)
    8685    , m_suspendPendingRequestsCount(0)
    … …  
    9897    RefPtr<SubresourceLoader> loader = SubresourceLoader::create(frame, resource, request, options);
    9998    if (loader)
    100         scheduleLoad(*loader);
     99        scheduleLoad(loader.get());
    101100#if PLATFORM(IOS)
    102101    // Since we defer loader initialization until scheduling on iOS, the frame
    … …  
    120119    RefPtr<NetscapePlugInStreamLoader> loader = NetscapePlugInStreamLoader::create(frame, client, request);
    121120    if (loader)
    122         scheduleLoad(*loader);
     121        scheduleLoad(loader.get());
    123122    return loader;
    124123}
    125124
    126 void WebResourceLoadScheduler::scheduleLoad(ResourceLoader& resourceLoader)
    127 {
    128     LOG(ResourceLoading, "WebResourceLoadScheduler::load resource %p '%s'", &resourceLoader, resourceLoader.url().string().latin1().data());
     125void WebResourceLoadScheduler::scheduleLoad(ResourceLoader* resourceLoader)
     126{
     127    ASSERT(resourceLoader);
     128
     129    LOG(ResourceLoading, "WebResourceLoadScheduler::load resource %p '%s'", resourceLoader, resourceLoader->url().string().latin1().data());
    129130
    130131#if PLATFORM(IOS)
    131132    // If there's a web archive resource for this URL, we don't need to schedule the load since it will never touch the network.
    132     if (!isSuspendingPendingRequests() && resourceLoader.documentLoader()->archiveResourceForURL(resourceLoader.iOSOriginalRequest().url())) {
    133         resourceLoader.startLoading();
     133    if (!isSuspendingPendingRequests() && resourceLoader->documentLoader()->archiveResourceForURL(resourceLoader->iOSOriginalRequest().url())) {
     134        resourceLoader->startLoading();
    134135        return;
    135136    }
    136137#else
    137     if (resourceLoader.documentLoader()->archiveResourceForURL(resourceLoader.request().url())) {
    138         resourceLoader.start();
    139         return;
    140     }
    141 #endif
    142 
    143 #if PLATFORM(IOS)
    144     HostInformation* host = hostForURL(resourceLoader.iOSOriginalRequest().url(), CreateIfNotFound);
     138    if (resourceLoader->documentLoader()->archiveResourceForURL(resourceLoader->request().url())) {
     139        resourceLoader->start();
     140        return;
     141    }
     142#endif
     143
     144#if PLATFORM(IOS)
     145    HostInformation* host = hostForURL(resourceLoader->iOSOriginalRequest().url(), CreateIfNotFound);
    145146#else
    146     HostInformation* host = hostForURL(resourceLoader.url(), CreateIfNotFound);
    147 #endif
    148     ASSERT(host);
    149 
    150     ResourceLoadPriority priority = resourceLoader.request().priority();
     147    HostInformation* host = hostForURL(resourceLoader->url(), CreateIfNotFound);
     148#endif
     149
     150    ResourceLoadPriority priority = resourceLoader->request().priority();
    151151
    152152    bool hadRequests = host->hasRequests();
    … …  
    157157        // Serve all requests at once to keep the pipeline full at the network layer.
    158158        // FIXME: Does this code do anything useful, given that we also set maxRequestsInFlightPerHost to effectively unlimited on these platforms?
    159         servePendingRequests(*host, ResourceLoadPriority::VeryLow);
    160         return;
    161     }
    162 #endif
    163 
    164 #if PLATFORM(IOS)
    165     if ((priority > ResourceLoadPriority::Low || !resourceLoader.iOSOriginalRequest().url().protocolIsInHTTPFamily() || (priority == ResourceLoadPriority::Low && !hadRequests)) && !isSuspendingPendingRequests()) {
     159        servePendingRequests(host, ResourceLoadPriority::VeryLow);
     160        return;
     161    }
     162#endif
     163
     164#if PLATFORM(IOS)
     165    if ((priority > ResourceLoadPriority::Low || !resourceLoader->iOSOriginalRequest().url().protocolIsInHTTPFamily() || (priority == ResourceLoadPriority::Low && !hadRequests)) && !isSuspendingPendingRequests()) {
    166166        // Try to request important resources immediately.
    167         servePendingRequests(*host, priority);
     167        servePendingRequests(host, priority);
    168168        return;
    169169    }
    170170#else
    171     if (priority > ResourceLoadPriority::Low || !resourceLoader.url().protocolIsInHTTPFamily() || (priority == ResourceLoadPriority::Low && !hadRequests)) {
     171    if (priority > ResourceLoadPriority::Low || !resourceLoader->url().protocolIsInHTTPFamily() || (priority == ResourceLoadPriority::Low && !hadRequests)) {
    172172        // Try to request important resources immediately.
    173         servePendingRequests(*host, priority);
     173        servePendingRequests(host, priority);
    174174        return;
    175175    }
    … …  
    181181}
    182182
    183 void WebResourceLoadScheduler::remove(ResourceLoader& resourceLoader)
    184 {
    185     HostInformation* host = hostForURL(resourceLoader.url());
     183void WebResourceLoadScheduler::remove(ResourceLoader* resourceLoader)
     184{
     185    ASSERT(resourceLoader);
     186
     187    HostInformation* host = hostForURL(resourceLoader->url());
    186188    if (host)
    187189        host->remove(resourceLoader);
    … …  
    189191    // ResourceLoader::url() doesn't start returning the correct value until the load starts. If we get canceled before that, we need to look for originalRequest url instead.
    190192    // FIXME: ResourceLoader::url() should be made to return a sensible value at all times.
    191     if (!resourceLoader.iOSOriginalRequest().isNull()) {
    192         HostInformation* originalHost = hostForURL(resourceLoader.iOSOriginalRequest().url());
     193    if (!resourceLoader->iOSOriginalRequest().isNull()) {
     194        HostInformation* originalHost = hostForURL(resourceLoader->iOSOriginalRequest().url());
    193195        if (originalHost && originalHost != host)
    194196            originalHost->remove(resourceLoader);
    … …  
    198200}
    199201
    200 void WebResourceLoadScheduler::setDefersLoading(ResourceLoader&, bool)
    201 {
    202 }
    203 
    204 void WebResourceLoadScheduler::crossOriginRedirectReceived(ResourceLoader& resourceLoader, const URL& redirectURL)
    205 {
    206     HostInformation* oldHost = hostForURL(resourceLoader.url());
     202void WebResourceLoadScheduler::setDefersLoading(ResourceLoader*, bool)
     203{
     204}
     205
     206void WebResourceLoadScheduler::crossOriginRedirectReceived(ResourceLoader* resourceLoader, const URL& redirectURL)
     207{
     208    HostInformation* oldHost = hostForURL(resourceLoader->url());
    207209    ASSERT(oldHost);
    208210    if (!oldHost)
    … …  
    210212
    211213    HostInformation* newHost = hostForURL(redirectURL, CreateIfNotFound);
    212     ASSERT(newHost);
    213214
    214215    if (oldHost->name() == newHost->name())
    … …  
    230231
    231232    Vector<HostInformation*> hostsToServe;
    232     hostsToServe.reserveInitialCapacity(m_hosts.size());
    233     for (const auto& host : m_hosts.values())
    234         hostsToServe.uncheckedAppend(host.get());
     233    copyValuesToVector(m_hosts, hostsToServe);
    235234
    236235    for (auto* host : hostsToServe) {
    237236        if (host->hasRequests())
    238             servePendingRequests(*host, minimumPriority);
     237            servePendingRequests(host, minimumPriority);
    239238        else
    240             m_hosts.remove(host->name());
    241     }
    242 }
    243 
    244 void WebResourceLoadScheduler::servePendingRequests(HostInformation& host, ResourceLoadPriority minimumPriority)
    245 {
    246     LOG(ResourceLoading, "WebResourceLoadScheduler::servePendingRequests HostInformation.m_name='%s'", host.name().latin1().data());
     239            delete m_hosts.take(host->name());
     240    }
     241}
     242
     243void WebResourceLoadScheduler::servePendingRequests(HostInformation* host, ResourceLoadPriority minimumPriority)
     244{
     245    LOG(ResourceLoading, "WebResourceLoadScheduler::servePendingRequests HostInformation.m_name='%s'", host->name().latin1().data());
    247246
    248247    auto priority = ResourceLoadPriority::Highest;
    249248    while (true) {
    250         auto& requestsPending = host.requestsPending(priority);
     249        auto& requestsPending = host->requestsPending(priority);
    251250        while (!requestsPending.isEmpty()) {
    252             Ref<ResourceLoader> resourceLoader = requestsPending.first().copyRef();
     251            RefPtr<ResourceLoader> resourceLoader = requestsPending.first();
    253252
    254253            // For named hosts - which are only http(s) hosts - we should always enforce the connection limit.
    … …  
    256255            // and we don't know all stylesheets yet.
    257256            Document* document = resourceLoader->frameLoader() ? resourceLoader->frameLoader()->frame().document() : 0;
    258             bool shouldLimitRequests = !host.name().isNull() || (document && (document->parsing() || !document->haveStylesheetsLoaded()));
    259             if (shouldLimitRequests && host.limitRequests(priority))
     257            bool shouldLimitRequests = !host->name().isNull() || (document && (document->parsing() || !document->haveStylesheetsLoaded()));
     258            if (shouldLimitRequests && host->limitRequests(priority))
    260259                return;
    261260
    262261            requestsPending.removeFirst();
    263             host.addLoadInProgress(resourceLoader.get());
     262            host->addLoadInProgress(resourceLoader.get());
    264263#if PLATFORM(IOS)
    265264            if (!IOSApplication::isWebProcess()) {
    … …  
    287286    if (m_suspendPendingRequestsCount)
    288287        return;
    289     if (!m_hosts.isEmpty() || m_nonHTTPProtocolHost.hasRequests())
     288    if (!m_hosts.isEmpty() || m_nonHTTPProtocolHost->hasRequests())
    290289        scheduleServePendingRequests();
    291290}
    … …  
    333332}
    334333
    335 void WebResourceLoadScheduler::HostInformation::schedule(ResourceLoader& resourceLoader, ResourceLoadPriority priority)
     334void WebResourceLoadScheduler::HostInformation::schedule(ResourceLoader* resourceLoader, ResourceLoadPriority priority)
    336335{
    337336    m_requestsPending[priorityToIndex(priority)].append(resourceLoader);
    338337}
    339338   
    340 void WebResourceLoadScheduler::HostInformation::addLoadInProgress(ResourceLoader& resourceLoader)
    341 {
    342     LOG(ResourceLoading, "HostInformation '%s' loading '%s'. Current count %d", m_name.latin1().data(), resourceLoader.url().string().latin1().data(), m_requestsLoading.size());
     339void WebResourceLoadScheduler::HostInformation::addLoadInProgress(ResourceLoader* resourceLoader)
     340{
     341    LOG(ResourceLoading, "HostInformation '%s' loading '%s'. Current count %d", m_name.latin1().data(), resourceLoader->url().string().latin1().data(), m_requestsLoading.size());
    343342    m_requestsLoading.add(resourceLoader);
    344343}
    345344   
    346 void WebResourceLoadScheduler::HostInformation::remove(ResourceLoader& resourceLoader)
     345void WebResourceLoadScheduler::HostInformation::remove(ResourceLoader* resourceLoader)
    347346{
    348347    if (m_requestsLoading.remove(resourceLoader))
    … …  
    351350    for (auto& requestQueue : m_requestsPending) {
    352351        for (auto it = requestQueue.begin(), end = requestQueue.end(); it != end; ++it) {
    353             if (it->ptr() == &resourceLoader) {
     352            if (*it == resourceLoader) {
    354353                requestQueue.remove(it);
    355354                return;

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

    r203064 r203079  
    2121 */
    2222
    23 #pragma once
     23#ifndef WebResourceLoadScheduler_h
     24#define WebResourceLoadScheduler_h
    2425
    2526#include <WebCore/FrameLoaderTypes.h>
    … …  
    4748    RefPtr<WebCore::SubresourceLoader> loadResource(WebCore::Frame&, WebCore::CachedResource&, const WebCore::ResourceRequest&, const WebCore::ResourceLoaderOptions&) override;
    4849    void loadResourceSynchronously(WebCore::NetworkingContext*, unsigned long, const WebCore::ResourceRequest&, WebCore::StoredCredentials, WebCore::ClientCredentialPolicy, WebCore::ResourceError&, WebCore::ResourceResponse&, Vector<char>&) override;
    49     void remove(WebCore::ResourceLoader&) override;
    50     void setDefersLoading(WebCore::ResourceLoader&, bool) override;
    51     void crossOriginRedirectReceived(WebCore::ResourceLoader&, const WebCore::URL& redirectURL) override;
     50    void remove(WebCore::ResourceLoader*) override;
     51    void setDefersLoading(WebCore::ResourceLoader*, bool) override;
     52    void crossOriginRedirectReceived(WebCore::ResourceLoader*, const WebCore::URL& redirectURL) override;
    5253   
    5354    void servePendingRequests(WebCore::ResourceLoadPriority minimumPriority = WebCore::ResourceLoadPriority::VeryLow) override;
    … …  
    6667
    6768private:
    68     void scheduleLoad(WebCore::ResourceLoader&);
     69    void scheduleLoad(WebCore::ResourceLoader*);
    6970    void scheduleServePendingRequests();
    7071    void requestTimerFired();
    … …  
    7980       
    8081        const String& name() const { return m_name; }
    81         void schedule(WebCore::ResourceLoader&, WebCore::ResourceLoadPriority = WebCore::ResourceLoadPriority::VeryLow);
    82         void addLoadInProgress(WebCore::ResourceLoader&);
    83         void remove(WebCore::ResourceLoader&);
     82        void schedule(WebCore::ResourceLoader*, WebCore::ResourceLoadPriority = WebCore::ResourceLoadPriority::VeryLow);
     83        void addLoadInProgress(WebCore::ResourceLoader*);
     84        void remove(WebCore::ResourceLoader*);
    8485        bool hasRequests() const;
    8586        bool limitRequests(WebCore::ResourceLoadPriority) const;
    8687
    87         typedef Deque<Ref<WebCore::ResourceLoader>> RequestQueue;
     88        typedef Deque<RefPtr<WebCore::ResourceLoader>> RequestQueue;
    8889        RequestQueue& requestsPending(WebCore::ResourceLoadPriority priority) { return m_requestsPending[priorityToIndex(priority)]; }
    8990
    … …  
    9293
    9394        std::array<RequestQueue, WebCore::resourceLoadPriorityCount> m_requestsPending;
    94         typedef HashSet<Ref<WebCore::ResourceLoader>> RequestMap;
     95        typedef HashSet<RefPtr<WebCore::ResourceLoader>> RequestMap;
    9596        RequestMap m_requestsLoading;
    9697        const String m_name;
    … …  
    104105   
    105106    HostInformation* hostForURL(const WebCore::URL&, CreateHostPolicy = FindOnly);
    106     void servePendingRequests(HostInformation&, WebCore::ResourceLoadPriority);
     107    WEBCORE_EXPORT void servePendingRequests(HostInformation*, WebCore::ResourceLoadPriority);
    107108
    108     HashMap<String, std::unique_ptr<HostInformation>> m_hosts;
    109     HostInformation m_nonHTTPProtocolHost;
     109    typedef HashMap<String, HostInformation*, StringHash> HostMap;
     110    HostMap m_hosts;
     111    HostInformation* m_nonHTTPProtocolHost;
    110112       
    111113    WebCore::Timer m_requestTimer;
    … …  
    114116    bool m_isSerialLoadingEnabled;
    115117};
     118
     119#endif

  • trunk/Source/WebKit2/ChangeLog

    r203075 r203079  
     12016-07-11  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r203064.
     4        https://bugs.webkit.org/show_bug.cgi?id=159642
     5
     6        This change causes LayoutTest crashes on WK1 ASan (Requested
     7        by ryanhaddad on #webkit).
     8
     9        Reverted changeset:
     10
     11        "Use refs for ResourceLoaders"
     12        https://bugs.webkit.org/show_bug.cgi?id=159592
     13        http://trac.webkit.org/changeset/203064
     14
    1152016-07-11  Nan Wang  <n_wang@apple.com>
    216

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

    r203064 r203079  
    218218void WebLoaderStrategy::scheduleInternallyFailedLoad(WebCore::ResourceLoader& resourceLoader)
    219219{
    220     m_internallyFailedResourceLoaders.add(resourceLoader);
     220    m_internallyFailedResourceLoaders.add(&resourceLoader);
    221221    m_internallyFailedLoadTimer.startOneShot(0);
    222222}
    … …  
    224224void WebLoaderStrategy::internallyFailedLoadTimerFired()
    225225{
    226     Vector<Ref<ResourceLoader>> internallyFailedResourceLoaders;
    227     internallyFailedResourceLoaders.reserveInitialCapacity(m_internallyFailedResourceLoaders.size());
    228     for (auto& loader : m_internallyFailedResourceLoaders)
    229         internallyFailedResourceLoaders.uncheckedAppend(loader.copyRef());
     226    Vector<RefPtr<ResourceLoader>> internallyFailedResourceLoaders;
     227    copyToVector(m_internallyFailedResourceLoaders, internallyFailedResourceLoaders);
    230228   
    231     for (auto& loader : internallyFailedResourceLoaders)
    232         loader->didFail(internalError(loader->url()));
     229    for (size_t i = 0; i < internallyFailedResourceLoaders.size(); ++i)
     230        internallyFailedResourceLoaders[i]->didFail(internalError(internallyFailedResourceLoaders[i]->url()));
    233231}
    234232
    … …  
    239237}
    240238
    241 void WebLoaderStrategy::remove(ResourceLoader& resourceLoader)
    242 {
    243     LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::remove, url '%s'", resourceLoader.url().string().utf8().data());
     239void WebLoaderStrategy::remove(ResourceLoader* resourceLoader)
     240{
     241    ASSERT(resourceLoader);
     242    LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::remove, url '%s'", resourceLoader->url().string().utf8().data());
    244243
    245244    if (m_internallyFailedResourceLoaders.contains(resourceLoader)) {
    … …  
    248247    }
    249248   
    250     ResourceLoadIdentifier identifier = resourceLoader.identifier();
     249    ResourceLoadIdentifier identifier = resourceLoader->identifier();
    251250    if (!identifier) {
    252251        LOG_ERROR("WebLoaderStrategy removing a ResourceLoader that has no identifier.");
    … …  
    266265}
    267266
    268 void WebLoaderStrategy::setDefersLoading(ResourceLoader& resourceLoader, bool defers)
    269 {
    270     ResourceLoadIdentifier identifier = resourceLoader.identifier();
     267void WebLoaderStrategy::setDefersLoading(ResourceLoader* resourceLoader, bool defers)
     268{
     269    ResourceLoadIdentifier identifier = resourceLoader->identifier();
    271270    WebProcess::singleton().networkConnection()->connection()->send(Messages::NetworkConnectionToWebProcess::SetDefersLoading(identifier, defers), 0);
    272271}
    273272
    274 void WebLoaderStrategy::crossOriginRedirectReceived(ResourceLoader&, const URL&)
     273void WebLoaderStrategy::crossOriginRedirectReceived(ResourceLoader*, const URL&)
    275274{
    276275    // We handle cross origin redirects entirely within the NetworkProcess.

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

    r203064 r203079  
    4747    void loadResourceSynchronously(WebCore::NetworkingContext*, unsigned long resourceLoadIdentifier, const WebCore::ResourceRequest&, WebCore::StoredCredentials, WebCore::ClientCredentialPolicy, WebCore::ResourceError&, WebCore::ResourceResponse&, Vector<char>& data) override;
    4848
    49     void remove(WebCore::ResourceLoader&) override;
    50     void setDefersLoading(WebCore::ResourceLoader&, bool) override;
    51     void crossOriginRedirectReceived(WebCore::ResourceLoader&, const WebCore::URL& redirectURL) override;
     49    void remove(WebCore::ResourceLoader*) override;
     50    void setDefersLoading(WebCore::ResourceLoader*, bool) override;
     51    void crossOriginRedirectReceived(WebCore::ResourceLoader*, const WebCore::URL& redirectURL) override;
    5252   
    5353    void servePendingRequests(WebCore::ResourceLoadPriority minimumPriority) override;
    … …  
    6969    void startLocalLoad(WebCore::ResourceLoader&);
    7070
    71     HashSet<Ref<WebCore::ResourceLoader>> m_internallyFailedResourceLoaders;
     71    HashSet<RefPtr<WebCore::ResourceLoader>> m_internallyFailedResourceLoaders;
    7272    RunLoop::Timer<WebLoaderStrategy> m_internallyFailedLoadTimer;
    7373   
Note: See TracChangeset for help on using the changeset viewer.