Changeset 268261 in webkit


Ignore:
Timestamp:
Oct 9, 2020 9:24:25 AM (4 years ago)
Author:
achristensen@apple.com
Message:

Use sendWithAsyncReply for NetworkProcess::CancelDownload
​https://bugs.webkit.org/show_bug.cgi?id=217420

Reviewed by Youenn Fablet.

Source/WebKit:

This paves the way for a good download API that has a completion handler when you call cancel that gives you the resume data if it can.
Currently you have to call cancel on the download, wait for didCancel on the delegate, then get the resume data from the download again.
This has the side effect of DownloadMonitor cancellations calling didFailWithError instead of didCancel, which makes sense and shouldn't
cause any problems in practice. Safari is the only API client that uses this, and it behaves similarly in didCancel and didFailWithError.

  • NetworkProcess/Downloads/Download.cpp:

(WebKit::Download::cancel):
(WebKit::Download::didCancel):

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

(WebKit::DownloadManager::cancelDownload):

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

(WebKit::DownloadMonitor::timerFired):

  • NetworkProcess/Downloads/PendingDownload.cpp:

(WebKit::PendingDownload::cancel):

  • NetworkProcess/Downloads/PendingDownload.h:
  • NetworkProcess/Downloads/cocoa/WKDownloadProgress.mm:

(-[WKDownloadProgress performCancel]):

  • NetworkProcess/NetworkProcess.cpp:

(WebKit::NetworkProcess::cancelDownload):
(WebKit::NetworkProcess::findPendingDownloadLocation):
(WebKit::NetworkProcess::pendingDownloadCanceled): Deleted.

  • NetworkProcess/NetworkProcess.h:
  • NetworkProcess/NetworkProcess.messages.in:
  • UIProcess/Downloads/DownloadProxy.cpp:

(WebKit::createData):
(WebKit::DownloadProxy::cancel):
(WebKit::DownloadProxy::didCancel): Deleted.

  • UIProcess/Downloads/DownloadProxy.h:
  • UIProcess/Downloads/DownloadProxy.messages.in:

Tools:

  • TestWebKitAPI/Tests/WebKitCocoa/Download.mm:

(-[WaitUntilDownloadCanceledDelegate _download:didFailWithError:]):
(-[DownloadMonitorTestDelegate _download:didFailWithError:]):
(-[DownloadMonitorTestDelegate waitForDidFail]):
(-[DownloadMonitorTestDelegate stopWaitingForDidFail]):
(TestWebKitAPI::monitorDelegate):
(TestWebKitAPI::webViewWithDownloadMonitorSpeedMultiplier):
(TestWebKitAPI::downloadAtRate):
(TestWebKitAPI::TEST):
(-[WaitUntilDownloadCanceledDelegate _downloadDidCancel:]): Deleted.
(-[DownloadMonitorTestDelegate _downloadDidCancel:]): Deleted.

Location:
trunk
Files:
20 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit/ChangeLog

    r268257 r268261  
     12020-10-09  Alex Christensen  <achristensen@webkit.org>
     2
     3        Use sendWithAsyncReply for NetworkProcess::CancelDownload
     4        https://bugs.webkit.org/show_bug.cgi?id=217420
     5
     6        Reviewed by Youenn Fablet.
     7
     8        This paves the way for a good download API that has a completion handler when you call cancel that gives you the resume data if it can.
     9        Currently you have to call cancel on the download, wait for didCancel on the delegate, then get the resume data from the download again.
     10        This has the side effect of DownloadMonitor cancellations calling didFailWithError instead of didCancel, which makes sense and shouldn't
     11        cause any problems in practice.  Safari is the only API client that uses this, and it behaves similarly in didCancel and didFailWithError.
     12
     13        * NetworkProcess/Downloads/Download.cpp:
     14        (WebKit::Download::cancel):
     15        (WebKit::Download::didCancel):
     16        * NetworkProcess/Downloads/Download.h:
     17        * NetworkProcess/Downloads/DownloadManager.cpp:
     18        (WebKit::DownloadManager::cancelDownload):
     19        * NetworkProcess/Downloads/DownloadManager.h:
     20        * NetworkProcess/Downloads/DownloadMonitor.cpp:
     21        (WebKit::DownloadMonitor::timerFired):
     22        * NetworkProcess/Downloads/PendingDownload.cpp:
     23        (WebKit::PendingDownload::cancel):
     24        * NetworkProcess/Downloads/PendingDownload.h:
     25        * NetworkProcess/Downloads/cocoa/WKDownloadProgress.mm:
     26        (-[WKDownloadProgress performCancel]):
     27        * NetworkProcess/NetworkProcess.cpp:
     28        (WebKit::NetworkProcess::cancelDownload):
     29        (WebKit::NetworkProcess::findPendingDownloadLocation):
     30        (WebKit::NetworkProcess::pendingDownloadCanceled): Deleted.
     31        * NetworkProcess/NetworkProcess.h:
     32        * NetworkProcess/NetworkProcess.messages.in:
     33        * UIProcess/Downloads/DownloadProxy.cpp:
     34        (WebKit::createData):
     35        (WebKit::DownloadProxy::cancel):
     36        (WebKit::DownloadProxy::didCancel): Deleted.
     37        * UIProcess/Downloads/DownloadProxy.h:
     38        * UIProcess/Downloads/DownloadProxy.messages.in:
     39
    1402020-10-09  Youenn Fablet  <youenn@apple.com>
    241

  • trunk/Source/WebKit/NetworkProcess/Downloads/Download.cpp

    r268017 r268261  
    8787}
    8888
    89 void Download::cancel()
     89void Download::cancel(CompletionHandler<void(const IPC::DataReference&)>&& completionHandler, IgnoreDidFailCallback ignoreDidFailCallback)
    9090{
    9191    RELEASE_ASSERT(isMainThread());
    9292
    93     if (m_wasCanceled)
    94         return;
    95     m_wasCanceled = true;
     93    // URLSession:task:didCompleteWithError: is still called after cancelByProducingResumeData's completionHandler.
     94    // If this cancel request came from the API, we do not want to send DownloadProxy::DidFail because the
     95    // completionHandler will inform the API that the cancellation succeeded.
     96    m_ignoreDidFailCallback = ignoreDidFailCallback;
     97
     98    auto completionHandlerWrapper = [this, weakThis = makeWeakPtr(*this), completionHandler = WTFMove(completionHandler)] (const IPC::DataReference& resumeData) mutable {
     99        completionHandler(resumeData);
     100        if (!weakThis || m_ignoreDidFailCallback == IgnoreDidFailCallback::No)
     101            return;
     102        RELEASE_LOG_IF_ALLOWED("didCancel: (id = %" PRIu64 ")", downloadID().toUInt64());
     103        if (auto extension = std::exchange(m_sandboxExtension, nullptr))
     104            extension->revoke();
     105        m_downloadManager.downloadFinished(*this);
     106    };
    96107
    97108    if (m_download) {
    98109        m_download->cancel();
    99         didCancel({ });
     110        completionHandlerWrapper({ });
    100111        return;
    101112    }
    102     platformCancelNetworkLoad();
     113    platformCancelNetworkLoad(WTFMove(completionHandlerWrapper));
    103114}
    104115
    … …  
    146157void Download::didFail(const ResourceError& error, const IPC::DataReference& resumeData)
    147158{
     159    if (m_ignoreDidFailCallback == IgnoreDidFailCallback::Yes)
     160        return;
     161
    148162    RELEASE_LOG_IF_ALLOWED("didFail: (id = %" PRIu64 ", isTimeout = %d, isCancellation = %d, errCode = %d)",
    149163        downloadID().toUInt64(), error.isTimeout(), error.isCancellation(), error.errorCode());
    150164
    151165    send(Messages::DownloadProxy::DidFail(error, resumeData));
    152 
    153     if (m_sandboxExtension) {
    154         m_sandboxExtension->revoke();
    155         m_sandboxExtension = nullptr;
    156     }
    157     m_downloadManager.downloadFinished(*this);
    158 }
    159 
    160 void Download::didCancel(const IPC::DataReference& resumeData)
    161 {
    162     RELEASE_LOG_IF_ALLOWED("didCancel: (id = %" PRIu64 ")", downloadID().toUInt64());
    163 
    164     send(Messages::DownloadProxy::DidCancel(resumeData));
    165166
    166167    if (m_sandboxExtension) {
    … …  
    191192
    192193#if !PLATFORM(COCOA)
    193 void Download::platformCancelNetworkLoad()
    194 {
     194void Download::platformCancelNetworkLoad(CompletionHandler<void(const IPC::DataReference&)>&& completionHandler)
     195{
     196    completionHandler({ });
    195197}
    196198

  • trunk/Source/WebKit/NetworkProcess/Downloads/Download.h

    r261898 r268261  
    7777
    7878    void resume(const IPC::DataReference& resumeData, const String& path, SandboxExtension::Handle&&);
    79     void cancel();
     79    enum class IgnoreDidFailCallback : bool { No, Yes };
     80    void cancel(CompletionHandler<void(const IPC::DataReference&)>&&, IgnoreDidFailCallback);
    8081#if PLATFORM(COCOA)
    8182    void publishProgress(const URL&, SandboxExtension::Handle&&);
    … …  
    9293    void didFinish();
    9394    void didFail(const WebCore::ResourceError&, const IPC::DataReference& resumeData);
    94     void didCancel(const IPC::DataReference& resumeData);
    9595
    9696    bool isAlwaysOnLoggingAllowed() const;
    97     bool wasCanceled() const { return m_wasCanceled; }
    9897
    9998    void applicationDidEnterBackground() { m_monitor.applicationDidEnterBackground(); }
    … …  
    108107    uint64_t messageSenderDestinationID() const override;
    109108
    110     void platformCancelNetworkLoad();
     109    void platformCancelNetworkLoad(CompletionHandler<void(const IPC::DataReference&)>&&);
    111110    void platformDestroyDownload();
    112111
    … …  
    125124    PAL::SessionID m_sessionID;
    126125    String m_suggestedName;
    127     bool m_wasCanceled { false };
    128126    bool m_hasReceivedData { false };
     127    IgnoreDidFailCallback m_ignoreDidFailCallback { IgnoreDidFailCallback::No };
    129128    DownloadMonitor m_monitor { *this };
    130129    unsigned m_testSpeedMultiplier { 1 };
     130    CompletionHandler<void(const IPC::DataReference&)> m_cancelCompletionHandler;
    131131};
    132132

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

    r268008 r268261  
    110110}
    111111
    112 void DownloadManager::cancelDownload(DownloadID downloadID)
     112void DownloadManager::cancelDownload(DownloadID downloadID, CompletionHandler<void(const IPC::DataReference&)>&& completionHandler)
    113113{
    114114    if (auto* download = m_downloads.get(downloadID)) {
    115115        ASSERT(!m_pendingDownloads.contains(downloadID));
    116         download->cancel();
     116        download->cancel(WTFMove(completionHandler), Download::IgnoreDidFailCallback::Yes);
    117117        return;
    118118    }
    119     if (auto pendingDownload = m_pendingDownloads.take(downloadID))
    120         pendingDownload->cancel();
     119    if (auto pendingDownload = m_pendingDownloads.take(downloadID)) {
     120        pendingDownload->cancel(WTFMove(completionHandler));
     121        return;
     122    }
     123    ASSERT_NOT_REACHED();
     124    completionHandler({ });
    121125}
    122126

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

    r268008 r268261  
    7474        virtual IPC::Connection* parentProcessConnectionForDownloads() = 0;
    7575        virtual AuthenticationManager& downloadsAuthenticationManager() = 0;
    76         virtual void pendingDownloadCanceled(DownloadID) = 0;
    7776        virtual NetworkSession* networkSession(PAL::SessionID) const = 0;
    7877        virtual void ref() const = 0;
    … …  
    9089    void resumeDownload(PAL::SessionID, DownloadID, const IPC::DataReference& resumeData, const String& path, SandboxExtension::Handle&&);
    9190
    92     void cancelDownload(DownloadID);
     91    void cancelDownload(DownloadID, CompletionHandler<void(const IPC::DataReference&)>&&);
    9392#if PLATFORM(COCOA)
    9493    void publishDownloadProgress(DownloadID, const URL&, SandboxExtension::Handle&&);

  • trunk/Source/WebKit/NetworkProcess/Downloads/DownloadMonitor.cpp

    r268017 r268261  
    119119    if (measuredThroughputRate() < throughputIntervals[m_interval].bytesPerSecond) {
    120120        RELEASE_LOG_IF_ALLOWED("timerFired: cancelling download (id = %" PRIu64 ")", m_download.downloadID().toUInt64());
    121         m_download.cancel();
     121        m_download.cancel([](auto&) { }, Download::IgnoreDidFailCallback::No);
    122122    } else if (m_interval + 1 < WTF_ARRAY_LENGTH(throughputIntervals)) {
    123123        RELEASE_LOG_IF_ALLOWED("timerFired: sufficient throughput rate (id = %" PRIu64 ")", m_download.downloadID().toUInt64());

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

    r268017 r268261  
    7373}
    7474
    75 void PendingDownload::cancel()
     75void PendingDownload::cancel(CompletionHandler<void(const IPC::DataReference&)>&& completionHandler)
    7676{
    7777    ASSERT(m_networkLoad);
    7878    m_networkLoad->cancel();
    79     send(Messages::DownloadProxy::DidCancel({ }));
     79    completionHandler({ });
    8080}
    8181

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

    r268017 r268261  
    5454
    5555    void continueWillSendRequest(WebCore::ResourceRequest&&);
    56     void cancel();
     56    void cancel(CompletionHandler<void(const IPC::DataReference&)>&&);
    5757
    5858#if PLATFORM(COCOA)

  • trunk/Source/WebKit/NetworkProcess/Downloads/cocoa/DownloadCocoa.mm

    r261153 r268261  
    3232#import <pal/spi/cf/CFNetworkSPI.h>
    3333#import <pal/spi/cocoa/NSProgressSPI.h>
     34#import <wtf/BlockPtr.h>
    3435
    3536namespace WebKit {
    … …  
    8081}
    8182   
    82 void Download::platformCancelNetworkLoad()
     83void Download::platformCancelNetworkLoad(CompletionHandler<void(const IPC::DataReference&)>&& completionHandler)
    8384{
    8485    ASSERT(m_downloadTask);
    85 
    86     // The download's resume data is accessed in the network session delegate
    87     // method -URLSession:task:didCompleteWithError: instead of inside this block,
    88     // to avoid race conditions between the two. Calling -cancel is not sufficient
    89     // here because CFNetwork won't provide the resume data unless we ask for it.
    90     [m_downloadTask cancelByProducingResumeData:^(NSData *resumeData) {
    91         UNUSED_PARAM(resumeData);
    92     }];
     86    [m_downloadTask cancelByProducingResumeData:makeBlockPtr([completionHandler = WTFMove(completionHandler)] (NSData *resumeData) mutable {
     87        auto resumeDataReference = resumeData ? IPC::DataReference { static_cast<const uint8_t*>(resumeData.bytes), resumeData.length } : IPC::DataReference { };
     88        completionHandler(resumeDataReference);
     89    }).get()];
    9390}
    9491

  • trunk/Source/WebKit/NetworkProcess/Downloads/cocoa/WKDownloadProgress.mm

    r255455 r268261  
    4747{
    4848    if (m_download)
    49         m_download->cancel();
     49        m_download->cancel([](auto&) { }, WebKit::Download::IgnoreDidFailCallback::No);
    5050    m_download = nullptr;
    5151}

  • trunk/Source/WebKit/NetworkProcess/NetworkProcess.cpp

    r268017 r268261  
    20722072}
    20732073
    2074 void NetworkProcess::cancelDownload(DownloadID downloadID)
    2075 {
    2076     downloadManager().cancelDownload(downloadID);
     2074void NetworkProcess::cancelDownload(DownloadID downloadID, CompletionHandler<void(const IPC::DataReference&)>&& completionHandler)
     2075{
     2076    downloadManager().cancelDownload(downloadID, WTFMove(completionHandler));
    20772077}
    20782078
    … …  
    20872087{
    20882088    downloadManager().continueWillSendRequest(downloadID, WTFMove(request));
    2089 }
    2090 
    2091 void NetworkProcess::pendingDownloadCanceled(DownloadID downloadID)
    2092 {
    2093     downloadProxyConnection()->send(Messages::DownloadProxy::DidCancel({ }), downloadID.toUInt64());
    20942089}
    20952090
    … …  
    21062101    downloadProxyConnection()->sendWithAsyncReply(Messages::DownloadProxy::DecideDestinationWithSuggestedFilename(suggestedFilename), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler), networkDataTask = makeRef(networkDataTask)] (String&& destination, SandboxExtension::Handle&& sandboxExtensionHandle, AllowOverwrite allowOverwrite) mutable {
    21072102        auto downloadID = networkDataTask->pendingDownloadID();
    2108         if (destination.isEmpty()) {
    2109             downloadManager().cancelDownload(downloadID);
    2110             completionHandler(PolicyAction::Ignore);
    2111             return;
    2112         }
     2103        if (destination.isEmpty())
     2104            return completionHandler(PolicyAction::Ignore);
    21132105        networkDataTask->setPendingDownloadLocation(destination, WTFMove(sandboxExtensionHandle), allowOverwrite == AllowOverwrite::Yes);
    21142106        completionHandler(PolicyAction::Download);

  • trunk/Source/WebKit/NetworkProcess/NetworkProcess.h

    r268017 r268261  
    404404    IPC::Connection* parentProcessConnectionForDownloads() override { return parentProcessConnection(); }
    405405    AuthenticationManager& downloadsAuthenticationManager() override;
    406     void pendingDownloadCanceled(DownloadID) override;
    407406
    408407    // Message Handlers
    … …  
    425424    void downloadRequest(PAL::SessionID, DownloadID, const WebCore::ResourceRequest&, Optional<NavigatingToAppBoundDomain>, const String& suggestedFilename);
    426425    void resumeDownload(PAL::SessionID, DownloadID, const IPC::DataReference& resumeData, const String& path, SandboxExtension::Handle&&);
    427     void cancelDownload(DownloadID);
     426    void cancelDownload(DownloadID, CompletionHandler<void(const IPC::DataReference&)>&&);
    428427#if PLATFORM(COCOA)
    429428    void publishDownloadProgress(DownloadID, const URL&, SandboxExtension::Handle&&);

  • trunk/Source/WebKit/NetworkProcess/NetworkProcess.messages.in

    r268008 r268261  
    5252    DownloadRequest(PAL::SessionID sessionID, WebKit::DownloadID downloadID, WebCore::ResourceRequest request, enum:bool Optional<WebKit::NavigatingToAppBoundDomain> isNavigatingToAppBoundDomain, String suggestedFilename)
    5353    ResumeDownload(PAL::SessionID sessionID, WebKit::DownloadID downloadID, IPC::DataReference resumeData, String path, WebKit::SandboxExtension::Handle sandboxExtensionHandle)
    54     CancelDownload(WebKit::DownloadID downloadID)
     54    CancelDownload(WebKit::DownloadID downloadID) -> (IPC::DataReference resumeData) Async
    5555#if PLATFORM(COCOA)
    5656    PublishDownloadProgress(WebKit::DownloadID downloadID, URL url, WebKit::SandboxExtension::Handle sandboxExtensionHandle)

  • trunk/Source/WebKit/NetworkProcess/cocoa/NetworkSessionCocoa.mm

    r268017 r268261  
    770770
    771771        auto resumeDataReference = resumeData ? IPC::DataReference { static_cast<const uint8_t*>(resumeData.bytes), resumeData.length } : IPC::DataReference { };
    772 
    773         if (download->wasCanceled())
    774             download->didCancel(resumeDataReference);
    775         else
    776             download->didFail(error, resumeDataReference);
     772        download->didFail(error, resumeDataReference);
    777773    }
    778774}

  • trunk/Source/WebKit/UIProcess/Downloads/DownloadProxy.cpp

    r268065 r268261  
    6262DownloadProxy::~DownloadProxy() = default;
    6363
     64static RefPtr<API::Data> createData(const IPC::DataReference& data)
     65{
     66    if (data.isEmpty())
     67        return nullptr;
     68    return API::Data::create(data.data(), data.size());
     69}
     70
    6471void DownloadProxy::cancel()
    6572{
    66     if (m_dataStore)
    67         m_dataStore->networkProcess().send(Messages::NetworkProcess::CancelDownload(m_downloadID), 0);
     73    if (m_dataStore) {
     74        m_dataStore->networkProcess().sendWithAsyncReply(Messages::NetworkProcess::CancelDownload(m_downloadID), [this, protectedThis = makeRef(*this)] (const IPC::DataReference& resumeData) {
     75            m_resumeData = createData(resumeData);
     76            m_client->didCancel(*this);
     77            m_downloadProxyMap.downloadFinished(*this);
     78        });
     79    }
    6880}
    6981
    … …  
    162174}
    163175
    164 static RefPtr<API::Data> createData(const IPC::DataReference& data)
    165 {
    166     if (data.isEmpty())
    167         return 0;
    168 
    169     return API::Data::create(data.data(), data.size());
    170 }
    171 
    172176void DownloadProxy::didFail(const ResourceError& error, const IPC::DataReference& resumeData)
    173177{
    … …  
    180184}
    181185
    182 void DownloadProxy::didCancel(const IPC::DataReference& resumeData)
    183 {
    184     m_resumeData = createData(resumeData);
    185 
    186     m_client->didCancel(*this);
    187 
    188     // This can cause the DownloadProxy object to be deleted.
    189     m_downloadProxyMap.downloadFinished(*this);
    190 }
    191 
    192186} // namespace WebKit
    193187

  • trunk/Source/WebKit/UIProcess/Downloads/DownloadProxy.h

    r268065 r268261  
    117117    void didFinish();
    118118    void didFail(const WebCore::ResourceError&, const IPC::DataReference& resumeData);
    119     void didCancel(const IPC::DataReference& resumeData);
    120119    void willSendRequest(WebCore::ResourceRequest&& redirectRequest, const WebCore::ResourceResponse& redirectResponse);
    121120    void decideDestinationWithSuggestedFilename(const String& suggestedFilename, CompletionHandler<void(String, SandboxExtension::Handle, AllowOverwrite)>&&);

  • trunk/Source/WebKit/UIProcess/Downloads/DownloadProxy.messages.in

    r268008 r268261  
    3232    DidFinish()
    3333    DidFail(WebCore::ResourceError error, IPC::DataReference resumeData)
    34     DidCancel(IPC::DataReference resumeData)
    3534}

  • trunk/Tools/ChangeLog

    r268258 r268261  
     12020-10-09  Alex Christensen  <achristensen@webkit.org>
     2
     3        Use sendWithAsyncReply for NetworkProcess::CancelDownload
     4        https://bugs.webkit.org/show_bug.cgi?id=217420
     5
     6        Reviewed by Youenn Fablet.
     7
     8        * TestWebKitAPI/Tests/WebKitCocoa/Download.mm:
     9        (-[WaitUntilDownloadCanceledDelegate _download:didFailWithError:]):
     10        (-[DownloadMonitorTestDelegate _download:didFailWithError:]):
     11        (-[DownloadMonitorTestDelegate waitForDidFail]):
     12        (-[DownloadMonitorTestDelegate stopWaitingForDidFail]):
     13        (TestWebKitAPI::monitorDelegate):
     14        (TestWebKitAPI::webViewWithDownloadMonitorSpeedMultiplier):
     15        (TestWebKitAPI::downloadAtRate):
     16        (TestWebKitAPI::TEST):
     17        (-[WaitUntilDownloadCanceledDelegate _downloadDidCancel:]): Deleted.
     18        (-[DownloadMonitorTestDelegate _downloadDidCancel:]): Deleted.
     19
    1202020-10-09  Lauro Moura  <lmoura@igalia.com>
    221

  • trunk/Tools/TestWebKitAPI/Tests/WebKitCocoa/Download.mm

    r267763 r268261  
    770770}
    771771
    772 - (void)_downloadDidCancel:(_WKDownload *)download
    773 {
     772- (void)_download:(_WKDownload *)download didFailWithError:(NSError *)error
     773{
     774    EXPECT_WK_STREQ(error.domain, NSURLErrorDomain);
     775    EXPECT_EQ(error.code, NSURLErrorCancelled);
    774776    isDone = true;
    775777}
    … …  
    799801
    800802static bool receivedData;
    801 static bool didCancel;
    802803static RetainPtr<NSString> destination;
    803804
    804805@interface DownloadMonitorTestDelegate : NSObject <_WKDownloadDelegate>
    805 @end
    806 
    807 @implementation DownloadMonitorTestDelegate
     806- (void)waitForDidFail;
     807- (void)stopWaitingForDidFail;
     808@end
     809
     810@implementation DownloadMonitorTestDelegate {
     811    bool didFail;
     812}
    808813
    809814- (void)_downloadDidStart:(_WKDownload *)download
    … …  
    812817}
    813818
    814 - (void)_downloadDidCancel:(_WKDownload *)download
    815 {
    816     didCancel = true;
     819- (void)_download:(_WKDownload *)download didFailWithError:(NSError *)error
     820{
     821    EXPECT_WK_STREQ(error.domain, NSURLErrorDomain);
     822    EXPECT_EQ(error.code, NSURLErrorCancelled);
     823    didFail = true;
     824}
     825
     826- (void)waitForDidFail
     827{
     828    didFail = false;
     829    while (!didFail)
     830        TestWebKitAPI::Util::spinRunLoop();
     831}
     832
     833- (void)stopWaitingForDidFail
     834{
     835    EXPECT_FALSE(didFail);
     836    didFail = true;
    817837}
    818838
    … …  
    860880}
    861881
     882static RetainPtr<DownloadMonitorTestDelegate> monitorDelegate()
     883{
     884    static auto delegate = adoptNS([DownloadMonitorTestDelegate new]);
     885    return delegate;
     886}
     887
    862888RetainPtr<WKWebView> webViewWithDownloadMonitorSpeedMultiplier(size_t multiplier)
    863889{
    864890    static auto navigationDelegate = adoptNS([DownloadNavigationDelegate new]);
    865     static auto downloadDelegate = adoptNS([DownloadMonitorTestDelegate new]);
    866891    auto processPoolConfiguration = adoptNS([_WKProcessPoolConfiguration new]);
    867892    auto processPool = adoptNS([[WKProcessPool alloc] _initWithConfiguration:processPoolConfiguration.get()]);
    … …  
    872897    auto webView = adoptNS([[WKWebView alloc] initWithFrame:NSMakeRect(0, 0, 800, 600) configuration:webViewConfiguration.get()]);
    873898    [webView setNavigationDelegate:navigationDelegate.get()];
    874     [webView configuration].processPool._downloadDelegate = downloadDelegate.get();
     899    [webView configuration].processPool._downloadDelegate = monitorDelegate().get();
    875900    return webView;
    876901}
    … …  
    893918    if (returnToForeground == AppReturnsToForeground::Yes)
    894919        [[webView configuration].websiteDataStore _synthesizeAppIsBackground:NO];
    895     didCancel = false;
    896     Util::run(&didCancel);
     920    [monitorDelegate() waitForDidFail];
    897921    terminateServer = true;
    898922    [[NSFileManager defaultManager] removeItemAtURL:[NSURL fileURLWithPath:destination.get() isDirectory:NO] error:nil];
    … …  
    909933    __block BOOL timeoutReached = NO;
    910934    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 2.5 * NSEC_PER_SEC), dispatch_get_main_queue(), ^{
    911         EXPECT_FALSE(didCancel);
    912         didCancel = true;
     935        [monitorDelegate() stopWaitingForDidFail];
    913936        timeoutReached = YES;
    914937    });
    … …  
    924947    __block BOOL timeoutReached = NO;
    925948    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 2.5 * NSEC_PER_SEC), dispatch_get_main_queue(), ^{
    926         EXPECT_FALSE(didCancel);
    927         didCancel = true;
     949        [monitorDelegate() stopWaitingForDidFail];
    928950        timeoutReached = YES;
    929951    });

  • trunk/Tools/TestWebKitAPI/Tests/WebKitCocoa/DownloadProgress.mm

    r255455 r268261  
    488488    [testRunner.get() receiveData:50];
    489489    [testRunner.get().progress cancel];
    490     [testRunner.get() waitForDownloadCanceled];
     490    [testRunner.get() waitForDownloadFailed];
    491491    [testRunner.get() waitToLoseProgress];
    492492
Note: See TracChangeset for help on using the changeset viewer.