Changeset 224037 in webkit


Ignore:
Timestamp:
Oct 26, 2017 11:58:29 AM (6 years ago)
Author:
commit-queue@webkit.org
Message:

[Curl] Rename CurlJobManager to CurlRequestScheduler
https://bugs.webkit.org/show_bug.cgi?id=178775

To match the meaning of the class.
It was originally meant to be more generic purpose, but as
other classes was introduced, the objective of the class is
now only to handle the life cycle of curl requests.

The delegate is also renamed to CurlRequestSchedulerClient.

Patch by Basuke Suzuki <Basuke Suzuki> on 2017-10-26
Reviewed by Alex Christensen.

  • platform/Curl.cmake:
  • platform/network/curl/CurlDownload.cpp:

(WebCore::CurlDownload::~CurlDownload):
(WebCore::CurlDownload::willSendRequest):

  • platform/network/curl/CurlDownload.h:
  • platform/network/curl/CurlRequest.cpp:

(WebCore::CurlRequest::CurlRequest):
(WebCore::CurlRequest::start):
(WebCore::CurlRequest::startWithJobManager):
(WebCore::CurlRequest::cancel):
(WebCore::CurlRequest::callClient):
(WebCore::CurlRequest::didReceiveData):
(WebCore::CurlRequest::didCompleteTransfer):
(WebCore::CurlRequest::invokeDidReceiveResponseForFile):
(WebCore::CurlRequest::invokeDidReceiveResponse):
(WebCore::CurlRequest::completeDidReceiveResponse):
(WebCore::CurlRequest::pausedStatusChanged):
(WebCore::CurlRequest::callDelegate): Deleted.

  • platform/network/curl/CurlRequest.h:

(WebCore::CurlRequest::create):
(WebCore::CurlRequest::setClient):
(WebCore::CurlRequest::setDelegate): Deleted.

  • platform/network/curl/CurlRequestClient.h: Renamed from Source/WebCore/platform/network/curl/CurlRequestDelegate.h.
  • platform/network/curl/CurlRequestScheduler.cpp: Renamed from Source/WebCore/platform/network/curl/CurlJobManager.cpp.

(WebCore::CurlJobList::startJobs):
(WebCore::CurlJobList::finishJobs):
(WebCore::CurlRequestScheduler::singleton):
(WebCore::CurlRequestScheduler::add):
(WebCore::CurlRequestScheduler::cancel):
(WebCore::CurlRequestScheduler::callOnWorkerThread):
(WebCore::CurlRequestScheduler::startThreadIfNeeded):
(WebCore::CurlRequestScheduler::stopThreadIfNoMoreJobRunning):
(WebCore::CurlRequestScheduler::stopThread):
(WebCore::CurlRequestScheduler::updateJobList):
(WebCore::CurlRequestScheduler::workerThread):

  • platform/network/curl/CurlRequestScheduler.h: Renamed from Source/WebCore/platform/network/curl/CurlJobManager.h.

(WebCore::CurlRequestScheduler::~CurlRequestScheduler):

  • platform/network/curl/CurlRequestSchedulerClient.h: Added.

(WebCore::CurlRequestSchedulerClient::~CurlRequestSchedulerClient):

  • platform/network/curl/ResourceHandleCurlDelegate.cpp:

(WebCore::ResourceHandleCurlDelegate::~ResourceHandleCurlDelegate):
(WebCore::ResourceHandleCurlDelegate::setAuthentication):
(WebCore::ResourceHandleCurlDelegate::continueAfterWillSendRequest):

  • platform/network/curl/ResourceHandleCurlDelegate.h:
Location:
trunk/Source/WebCore
Files:
1 added
8 edited
3 moved

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r224034 r224037  
     12017-10-26  Basuke Suzuki  <Basuke.Suzuki@sony.com>
     2
     3        [Curl] Rename CurlJobManager to CurlRequestScheduler
     4        https://bugs.webkit.org/show_bug.cgi?id=178775
     5
     6        To match the meaning of the class.
     7        It was originally meant to be more generic purpose, but as
     8        other classes was introduced, the objective of the class is
     9        now only to handle the life cycle of curl requests.
     10
     11        The delegate is also renamed to CurlRequestSchedulerClient.
     12
     13        Reviewed by Alex Christensen.
     14
     15        * platform/Curl.cmake:
     16        * platform/network/curl/CurlDownload.cpp:
     17        (WebCore::CurlDownload::~CurlDownload):
     18        (WebCore::CurlDownload::willSendRequest):
     19        * platform/network/curl/CurlDownload.h:
     20        * platform/network/curl/CurlRequest.cpp:
     21        (WebCore::CurlRequest::CurlRequest):
     22        (WebCore::CurlRequest::start):
     23        (WebCore::CurlRequest::startWithJobManager):
     24        (WebCore::CurlRequest::cancel):
     25        (WebCore::CurlRequest::callClient):
     26        (WebCore::CurlRequest::didReceiveData):
     27        (WebCore::CurlRequest::didCompleteTransfer):
     28        (WebCore::CurlRequest::invokeDidReceiveResponseForFile):
     29        (WebCore::CurlRequest::invokeDidReceiveResponse):
     30        (WebCore::CurlRequest::completeDidReceiveResponse):
     31        (WebCore::CurlRequest::pausedStatusChanged):
     32        (WebCore::CurlRequest::callDelegate): Deleted.
     33        * platform/network/curl/CurlRequest.h:
     34        (WebCore::CurlRequest::create):
     35        (WebCore::CurlRequest::setClient):
     36        (WebCore::CurlRequest::setDelegate): Deleted.
     37        * platform/network/curl/CurlRequestClient.h: Renamed from Source/WebCore/platform/network/curl/CurlRequestDelegate.h.
     38        * platform/network/curl/CurlRequestScheduler.cpp: Renamed from Source/WebCore/platform/network/curl/CurlJobManager.cpp.
     39        (WebCore::CurlJobList::startJobs):
     40        (WebCore::CurlJobList::finishJobs):
     41        (WebCore::CurlRequestScheduler::singleton):
     42        (WebCore::CurlRequestScheduler::add):
     43        (WebCore::CurlRequestScheduler::cancel):
     44        (WebCore::CurlRequestScheduler::callOnWorkerThread):
     45        (WebCore::CurlRequestScheduler::startThreadIfNeeded):
     46        (WebCore::CurlRequestScheduler::stopThreadIfNoMoreJobRunning):
     47        (WebCore::CurlRequestScheduler::stopThread):
     48        (WebCore::CurlRequestScheduler::updateJobList):
     49        (WebCore::CurlRequestScheduler::workerThread):
     50        * platform/network/curl/CurlRequestScheduler.h: Renamed from Source/WebCore/platform/network/curl/CurlJobManager.h.
     51        (WebCore::CurlRequestScheduler::~CurlRequestScheduler):
     52        * platform/network/curl/CurlRequestSchedulerClient.h: Added.
     53        (WebCore::CurlRequestSchedulerClient::~CurlRequestSchedulerClient):
     54        * platform/network/curl/ResourceHandleCurlDelegate.cpp:
     55        (WebCore::ResourceHandleCurlDelegate::~ResourceHandleCurlDelegate):
     56        (WebCore::ResourceHandleCurlDelegate::setAuthentication):
     57        (WebCore::ResourceHandleCurlDelegate::continueAfterWillSendRequest):
     58        * platform/network/curl/ResourceHandleCurlDelegate.h:
     59
    1602017-10-26  Antti Koivisto  <antti@apple.com>
    261
  • trunk/Source/WebCore/platform/Curl.cmake

    r222665 r224037  
    1111    platform/network/curl/CurlContext.cpp
    1212    platform/network/curl/CurlDownload.cpp
    13     platform/network/curl/CurlJobManager.cpp
    1413    platform/network/curl/CurlRequest.cpp
     14    platform/network/curl/CurlRequestScheduler.cpp
    1515    platform/network/curl/CurlSSLHandle.cpp
    1616    platform/network/curl/CurlSSLVerifier.cpp
  • trunk/Source/WebCore/platform/network/curl/CurlDownload.cpp

    r222828 r224037  
    4141{
    4242    if (m_curlRequest)
    43         m_curlRequest->setDelegate(nullptr);
     43        m_curlRequest->setClient(nullptr);
    4444}
    4545
     
    197197
    198198    m_curlRequest->cancel();
    199     m_curlRequest->setDelegate(nullptr);
     199    m_curlRequest->setClient(nullptr);
    200200
    201201    m_curlRequest = createCurlRequest(newRequest);
  • trunk/Source/WebCore/platform/network/curl/CurlDownload.h

    r222828 r224037  
    3131
    3232#include "CurlRequest.h"
    33 #include "CurlRequestDelegate.h"
     33#include "CurlRequestClient.h"
    3434#include "ResourceRequest.h"
    3535#include "ResourceResponse.h"
     
    4848};
    4949
    50 class CurlDownload : public ThreadSafeRefCounted<CurlDownload>, public CurlRequestDelegate {
     50class CurlDownload : public ThreadSafeRefCounted<CurlDownload>, public CurlRequestClient {
    5151public:
    5252    CurlDownload() = default;
  • trunk/Source/WebCore/platform/network/curl/CurlRequest.cpp

    r223995 r224037  
    2929#if USE(CURL)
    3030
    31 #include "CurlRequestDelegate.h"
     31#include "CurlRequestClient.h"
     32#include "CurlRequestScheduler.h"
    3233#include "MIMETypeRegistry.h"
    3334#include "ResourceError.h"
     
    3738namespace WebCore {
    3839
    39 CurlRequest::CurlRequest(const ResourceRequest&request, CurlRequestDelegate* delegate, bool shouldSuspend)
     40CurlRequest::CurlRequest(const ResourceRequest&request, CurlRequestClient* client, bool shouldSuspend)
    4041    : m_request(request.isolatedCopy())
    4142    , m_shouldSuspend(shouldSuspend)
     
    4344    ASSERT(isMainThread());
    4445
    45     setDelegate(delegate);
     46    setClient(client);
    4647    resolveBlobReferences(m_request);
    4748}
     
    7374
    7475    if (!m_isSyncRequest) {
    75         // For asynchronous, use CurlJobManager. Curl processes runs on sub thread.
     76        // For asynchronous, use CurlRequestScheduler. Curl processes runs on sub thread.
    7677        if (url.isLocalFile())
    7778            invokeDidReceiveResponseForFile(url);
     
    7980            startWithJobManager();
    8081    } else {
    81         // For synchronous, does not use CurlJobManager. Curl processes runs on main thread.
     82        // For synchronous, does not use CurlRequestScheduler. Curl processes runs on main thread.
    8283        // curl_easy_perform blocks until the transfer is finished.
    8384        retain();
     
    9697    ASSERT(isMainThread());
    9798
    98     CurlJobManager::singleton().add(this);
     99    CurlRequestScheduler::singleton().add(this);
    99100}
    100101
     
    109110
    110111    if (!m_isSyncRequest)
    111         CurlJobManager::singleton().cancel(this);
     112        CurlRequestScheduler::singleton().cancel(this);
    112113
    113114    setRequestPaused(false);
     
    130131
    131132/* `this` is protected inside this method. */
    132 void CurlRequest::callDelegate(WTF::Function<void(CurlRequestDelegate*)> task)
     133void CurlRequest::callClient(WTF::Function<void(CurlRequestClient*)> task)
    133134{
    134135    if (isMainThread()) {
    135         if (CurlRequestDelegate* delegate = m_delegate)
    136             task(delegate);
     136        if (CurlRequestClient* client = m_client)
     137            task(client);
    137138    } else {
    138139        callOnMainThread([protectedThis = makeRef(*this), task = WTFMove(task)]() mutable {
    139             if (CurlRequestDelegate* delegate = protectedThis->m_delegate)
    140                 task(delegate);
     140            if (CurlRequestClient* client = protectedThis->m_client)
     141                task(client);
    141142        });
    142143    }
     
    329330
    330331    if (receiveBytes) {
    331         callDelegate([this, buffer = WTFMove(buffer)](CurlRequestDelegate* delegate) mutable {
    332             if (delegate)
    333                 delegate->curlDidReceiveBuffer(WTFMove(buffer));
     332        callClient([this, buffer = WTFMove(buffer)](CurlRequestClient* client) mutable {
     333            if (client)
     334                client->curlDidReceiveBuffer(WTFMove(buffer));
    334335        });
    335336    }
     
    357358
    358359            finalizeTransfer();
    359             callDelegate([this](CurlRequestDelegate* delegate) {
    360                 if (delegate)
    361                     delegate->curlDidComplete();
     360            callClient([this](CurlRequestClient* client) {
     361                if (client)
     362                    client->curlDidComplete();
    362363            });
    363364        }
     
    368369
    369370        finalizeTransfer();
    370         callDelegate([this, error = resourceError.isolatedCopy()](CurlRequestDelegate* delegate) {
    371             if (delegate)
    372                 delegate->curlDidFailWithError(error);
     371        callClient([this, error = resourceError.isolatedCopy()](CurlRequestClient* client) {
     372            if (client)
     373                client->curlDidFailWithError(error);
    373374        });
    374375    }
     
    497498    if (!m_isSyncRequest) {
    498499        // DidReceiveResponse must not be called immediately
    499         CurlJobManager::singleton().callOnJobThread([protectedThis = makeRef(*this)]() {
     500        CurlRequestScheduler::singleton().callOnWorkerThread([protectedThis = makeRef(*this)]() {
    500501            protectedThis->invokeDidReceiveResponse(Action::StartTransfer);
    501502        });
     
    513514    m_actionAfterInvoke = behaviorAfterInvoke;
    514515
    515     callDelegate([this, response = m_response.isolatedCopy()](CurlRequestDelegate* delegate) {
    516         if (delegate)
    517             delegate->curlDidReceiveResponse(response);
     516    callClient([this, response = m_response.isolatedCopy()](CurlRequestClient* client) {
     517        if (client)
     518            client->curlDidReceiveResponse(response);
    518519    });
    519520}
     
    539540        // Keep the calling thread of didCompleteTransfer()
    540541        if (!m_isSyncRequest) {
    541             CurlJobManager::singleton().callOnJobThread([protectedThis = makeRef(*this), finishedResultCode = m_finishedResultCode]() {
     542            CurlRequestScheduler::singleton().callOnWorkerThread([protectedThis = makeRef(*this), finishedResultCode = m_finishedResultCode]() {
    542543                protectedThis->didCompleteTransfer(finishedResultCode);
    543544            });
     
    581582
    582583    if (!m_isSyncRequest && isMainThread()) {
    583         CurlJobManager::singleton().callOnJobThread([protectedThis = makeRef(*this), paused = isPaused()]() {
     584        CurlRequestScheduler::singleton().callOnWorkerThread([protectedThis = makeRef(*this), paused = isPaused()]() {
    584585            if (protectedThis->m_cancelled)
    585586                return;
  • trunk/Source/WebCore/platform/network/curl/CurlRequest.h

    r223995 r224037  
    2626#pragma once
    2727
    28 #include "CurlJobManager.h"
     28#include "CurlRequestSchedulerClient.h"
    2929#include "CurlResponse.h"
    3030#include "CurlSSLVerifier.h"
     
    3737namespace WebCore {
    3838
    39 class CurlRequestDelegate;
     39class CurlRequestClient;
    4040class ResourceError;
    4141class SharedBuffer;
    4242
    43 class CurlRequest : public ThreadSafeRefCounted<CurlRequest>, public CurlJobClient {
     43class CurlRequest : public ThreadSafeRefCounted<CurlRequest>, public CurlRequestSchedulerClient {
    4444    WTF_MAKE_NONCOPYABLE(CurlRequest);
    4545
    4646public:
    47     static Ref<CurlRequest> create(const ResourceRequest& request, CurlRequestDelegate* delegate, bool shouldSuspend = false)
     47    static Ref<CurlRequest> create(const ResourceRequest& request, CurlRequestClient* client, bool shouldSuspend = false)
    4848    {
    49         return adoptRef(*new CurlRequest(request, delegate, shouldSuspend));
     49        return adoptRef(*new CurlRequest(request, client, shouldSuspend));
    5050    }
    5151
    5252    virtual ~CurlRequest() = default;
    5353
    54     void setDelegate(CurlRequestDelegate* delegate) { m_delegate = delegate;  }
     54    void setClient(CurlRequestClient* client) { m_client = client;  }
    5555    void setUserPass(const String&, const String&);
    5656
     
    7979    };
    8080
    81     CurlRequest(const ResourceRequest&, CurlRequestDelegate*, bool shouldSuspend);
     81    CurlRequest(const ResourceRequest&, CurlRequestClient*, bool shouldSuspend);
    8282
    8383    void retain() override { ref(); }
     
    8787    void startWithJobManager();
    8888
    89     void callDelegate(WTF::Function<void(CurlRequestDelegate*)>);
     89    void callClient(WTF::Function<void(CurlRequestClient*)>);
    9090
    9191    // Transfer processing of Request body, Response header/body
     
    127127
    128128
    129     std::atomic<CurlRequestDelegate*> m_delegate { };
     129    std::atomic<CurlRequestClient*> m_client { };
    130130    bool m_isSyncRequest { false };
    131131    bool m_cancelled { false };
  • trunk/Source/WebCore/platform/network/curl/CurlRequestClient.h

    r224036 r224037  
    3434class SharedBuffer;
    3535
    36 class CurlRequestDelegate {
     36class CurlRequestClient {
    3737public:
    3838    virtual void curlDidReceiveResponse(const CurlResponse&) = 0;
  • trunk/Source/WebCore/platform/network/curl/CurlRequestScheduler.cpp

    r224036 r224037  
    2727
    2828#include "config.h"
    29 #include "CurlJobManager.h"
     29#include "CurlRequestScheduler.h"
    3030
    3131#if USE(CURL)
    3232
     33#include "CurlRequestSchedulerClient.h"
    3334#include <wtf/NeverDestroyed.h>
    3435
     
    4243    bool isEmpty() const { return m_activeJobs.isEmpty(); }
    4344
    44     void startJobs(HashSet<CurlJobClient*>&& jobs)
     45    void startJobs(HashSet<CurlRequestSchedulerClient*>&& jobs)
    4546    {
    4647        auto localJobs = WTFMove(jobs);
     
    5556    }
    5657
    57     void finishJobs(HashMap<CURL*, CURLcode>&& tickets, WTF::Function<void(CurlJobClient*, CURLcode)> completionHandler)
     58    void finishJobs(HashMap<CURL*, CURLcode>&& tickets, WTF::Function<void(CurlRequestSchedulerClient*, CURLcode)> completionHandler)
    5859    {
    5960        auto localTickets = WTFMove(tickets);
     
    6465            CURL* handle = ticket.key;
    6566            CURLcode result = ticket.value;
    66             CurlJobClient* client = m_activeJobs.inlineGet(handle);
     67            CurlRequestSchedulerClient* client = m_activeJobs.inlineGet(handle);
    6768
    6869            removeHandle(handle);
     
    7778
    7879private:
    79     HashMap<CURL*, CurlJobClient*> m_activeJobs;
     80    HashMap<CURL*, CurlRequestSchedulerClient*> m_activeJobs;
    8081};
    8182
    82 CurlJobManager& CurlJobManager::singleton()
    83 {
    84     static NeverDestroyed<CurlJobManager> sharedInstance;
     83CurlRequestScheduler& CurlRequestScheduler::singleton()
     84{
     85    static NeverDestroyed<CurlRequestScheduler> sharedInstance;
    8586    return sharedInstance;
    8687}
    8788
    88 bool CurlJobManager::add(CurlJobClient* client)
     89bool CurlRequestScheduler::add(CurlRequestSchedulerClient* client)
    8990{
    9091    ASSERT(isMainThread());
     
    105106}
    106107
    107 void CurlJobManager::cancel(CurlJobClient* client)
     108void CurlRequestScheduler::cancel(CurlRequestSchedulerClient* client)
    108109{
    109110    ASSERT(isMainThread());
     
    116117}
    117118
    118 void CurlJobManager::callOnJobThread(WTF::Function<void()>&& task)
     119void CurlRequestScheduler::callOnWorkerThread(WTF::Function<void()>&& task)
    119120{
    120121    {
     
    126127}
    127128
    128 void CurlJobManager::startThreadIfNeeded()
     129void CurlRequestScheduler::startThreadIfNeeded()
    129130{
    130131    ASSERT(isMainThread());
     
    143144}
    144145
    145 void CurlJobManager::stopThreadIfNoMoreJobRunning()
     146void CurlRequestScheduler::stopThreadIfNoMoreJobRunning()
    146147{
    147148    ASSERT(!isMainThread());
     
    153154}
    154155
    155 void CurlJobManager::stopThread()
     156void CurlRequestScheduler::stopThread()
    156157{
    157158    m_runThread = false;
     
    163164}
    164165
    165 void CurlJobManager::updateJobList(CurlJobList& jobs)
     166void CurlRequestScheduler::updateJobList(CurlJobList& jobs)
    166167{
    167168    ASSERT(!isMainThread());
    168169
    169     HashSet<CurlJobClient*> pendingJobs;
     170    HashSet<CurlRequestSchedulerClient*> pendingJobs;
    170171    HashMap<CURL*, CURLcode> cancelledJobs;
    171172    Vector<WTF::Function<void()>> taskQueue;
     
    184185    jobs.startJobs(WTFMove(pendingJobs));
    185186
    186     jobs.finishJobs(WTFMove(cancelledJobs), [](CurlJobClient* client, CURLcode) {
     187    jobs.finishJobs(WTFMove(cancelledJobs), [](CurlRequestSchedulerClient* client, CURLcode) {
    187188        client->didCancelTransfer();
    188189    });
    189190
    190     jobs.finishJobs(WTFMove(m_finishedJobs), [](CurlJobClient* client, CURLcode result) {
     191    jobs.finishJobs(WTFMove(m_finishedJobs), [](CurlRequestSchedulerClient* client, CURLcode result) {
    191192        client->didCompleteTransfer(result);
    192193    });
    193194}
    194195
    195 void CurlJobManager::workerThread()
     196void CurlRequestScheduler::workerThread()
    196197{
    197198    ASSERT(!isMainThread());
  • trunk/Source/WebCore/platform/network/curl/CurlRequestScheduler.h

    r224036 r224037  
    3838
    3939class CurlJobList;
     40class CurlRequestSchedulerClient;
    4041
    41 class CurlJobClient {
     42class CurlRequestScheduler {
     43    WTF_MAKE_NONCOPYABLE(CurlRequestScheduler);
     44    friend NeverDestroyed<CurlRequestScheduler>;
    4245public:
    43     virtual void retain() = 0;
    44     virtual void release() = 0;
     46    static CurlRequestScheduler& singleton();
    4547
    46     virtual CURL* handle() = 0;
    47     virtual CURL* setupTransfer() = 0;
    48     virtual void didCompleteTransfer(CURLcode) = 0;
    49     virtual void didCancelTransfer() = 0;
    50 };
     48    ~CurlRequestScheduler() { stopThread(); }
    5149
    52 class CurlJobManager {
    53     WTF_MAKE_NONCOPYABLE(CurlJobManager);
    54     friend NeverDestroyed<CurlJobManager>;
    55 public:
    56     static CurlJobManager& singleton();
     50    bool add(CurlRequestSchedulerClient*);
     51    void cancel(CurlRequestSchedulerClient*);
    5752
    58     ~CurlJobManager() { stopThread(); }
    59 
    60     bool add(CurlJobClient*);
    61     void cancel(CurlJobClient*);
    62 
    63     void callOnJobThread(WTF::Function<void()>&&);
     53    void callOnWorkerThread(WTF::Function<void()>&&);
    6454
    6555private:
    66     CurlJobManager() = default;
     56    CurlRequestScheduler() = default;
    6757
    6858    void startThreadIfNeeded();
     
    7565
    7666    RefPtr<Thread> m_thread;
    77     HashSet<CurlJobClient*> m_pendingJobs;
     67    HashSet<CurlRequestSchedulerClient*> m_pendingJobs;
    7868    HashMap<CURL*, CURLcode> m_finishedJobs;
    7969    HashMap<CURL*, CURLcode> m_cancelledJobs;
  • trunk/Source/WebCore/platform/network/curl/ResourceHandleCurlDelegate.cpp

    r223752 r224037  
    6262{
    6363    if (m_curlRequest)
    64         m_curlRequest->setDelegate(nullptr);
     64        m_curlRequest->setClient(nullptr);
    6565}
    6666
     
    125125    bool isSyncRequest = m_curlRequest->isSyncRequest();
    126126    m_curlRequest->cancel();
    127     m_curlRequest->setDelegate(nullptr);
     127    m_curlRequest->setClient(nullptr);
    128128
    129129    m_curlRequest = createCurlRequest(m_currentRequest);
     
    391391    bool isSyncRequest = m_curlRequest->isSyncRequest();
    392392    m_curlRequest->cancel();
    393     m_curlRequest->setDelegate(nullptr);
     393    m_curlRequest->setClient(nullptr);
    394394
    395395    m_curlRequest = createCurlRequest(m_currentRequest);
  • trunk/Source/WebCore/platform/network/curl/ResourceHandleCurlDelegate.h

    r222828 r224037  
    3030
    3131#include "Credential.h"
    32 #include "CurlRequestDelegate.h"
     32#include "CurlRequestClient.h"
    3333#include "ResourceRequest.h"
    3434
     
    4040class ResourceResponse;
    4141
    42 class ResourceHandleCurlDelegate final : public ThreadSafeRefCounted<ResourceHandleCurlDelegate>, public CurlRequestDelegate {
     42class ResourceHandleCurlDelegate final : public ThreadSafeRefCounted<ResourceHandleCurlDelegate>, public CurlRequestClient {
    4343public:
    4444    ResourceHandleCurlDelegate(ResourceHandle*);
Note: See TracChangeset for help on using the changeset viewer.