⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 224267 in webkit


Ignore:
Timestamp:
Oct 31, 2017, 6:13:04 PM (9 years ago)
Author:
achristensen@apple.com
Message:

Use asynchronous ResourceHandleClient calls for WebKit1
​https://bugs.webkit.org/show_bug.cgi?id=160677

Reviewed by Brady Eidson.

Source/WebCore:

Covered by existing tests.

  • PlatformAppleWin.cmake:
  • PlatformMac.cmake:
  • WebCore.xcodeproj/project.pbxproj:
  • loader/ResourceLoader.cpp:

(WebCore::ResourceLoader::willSendRequestAsync):
(WebCore::ResourceLoader::didReceiveResponseAsync):
(WebCore::ResourceLoader::canAuthenticateAgainstProtectionSpaceAsync):

  • loader/ResourceLoader.h:
  • loader/appcache/ApplicationCacheGroup.cpp:

(WebCore::ApplicationCacheGroup::didReceiveResponseAsync):
(WebCore::ApplicationCacheGroup::willSendRequestAsync):
(WebCore::ApplicationCacheGroup::canAuthenticateAgainstProtectionSpaceAsync):
(WebCore::ApplicationCacheGroup::didReceiveResponse): Deleted.

  • loader/appcache/ApplicationCacheGroup.h:
  • platform/network/BlobResourceHandle.cpp:

(WebCore::BlobResourceHandle::continueDidReceiveResponse):
(WebCore::BlobResourceHandle::getSizeForNext):
(WebCore::BlobResourceHandle::notifyResponseOnSuccess):
(WebCore::BlobResourceHandle::notifyResponseOnError):

  • platform/network/PingHandle.h:
  • platform/network/ResourceHandle.cpp:

(WebCore::ResourceHandle::didReceiveResponse):
(WebCore::ResourceHandle::usesAsyncCallbacks): Deleted.

  • platform/network/ResourceHandle.h:
  • platform/network/ResourceHandleClient.cpp:

(WebCore::ResourceHandleClient::~ResourceHandleClient):
(WebCore::ResourceHandleClient::willSendRequest): Deleted.
(WebCore::ResourceHandleClient::willSendRequestAsync): Deleted.
(WebCore::ResourceHandleClient::didReceiveResponseAsync): Deleted.
(WebCore::ResourceHandleClient::canAuthenticateAgainstProtectionSpaceAsync): Deleted.

  • platform/network/ResourceHandleClient.h:

(WebCore::ResourceHandleClient::didReceiveAuthenticationChallenge):
(WebCore::ResourceHandleClient::didReceiveResponse): Deleted.
(WebCore::ResourceHandleClient::usesAsyncCallbacks): Deleted.
(WebCore::ResourceHandleClient::canAuthenticateAgainstProtectionSpace): Deleted.

  • platform/network/ResourceHandleInternal.h:

(WebCore::ResourceHandleInternal::ResourceHandleInternal):

  • platform/network/SynchronousLoaderClient.cpp:

(WebCore::SynchronousLoaderClient::willSendRequestAsync):
(WebCore::SynchronousLoaderClient::canAuthenticateAgainstProtectionSpaceAsync):
(WebCore::SynchronousLoaderClient::didReceiveResponseAsync):
(WebCore::SynchronousLoaderClient::didFinishLoading):
(WebCore::SynchronousLoaderClient::didFail):
(WebCore::SynchronousLoaderClient::willSendRequest): Deleted.
(WebCore::SynchronousLoaderClient::canAuthenticateAgainstProtectionSpace): Deleted.
(WebCore::SynchronousLoaderClient::didReceiveResponse): Deleted.

  • platform/network/SynchronousLoaderClient.h:
  • platform/network/cf/ResourceHandleCFNet.cpp:

(WebCore::ResourceHandle::createCFURLConnection):
(WebCore::ResourceHandle::start):
(WebCore::ResourceHandle::willSendRequest):
(WebCore::ResourceHandle::shouldUseCredentialStorage):
(WebCore::ResourceHandle::canAuthenticateAgainstProtectionSpace):
(WebCore::ResourceHandle::platformLoadResourceSynchronously):

  • platform/network/cf/ResourceHandleCFURLConnectionDelegateWithOperationQueue.cpp:

(WebCore::ResourceHandleCFURLConnectionDelegateWithOperationQueue::ResourceHandleCFURLConnectionDelegateWithOperationQueue):
(WebCore::ResourceHandleCFURLConnectionDelegateWithOperationQueue::releaseHandle):
(WebCore::ResourceHandleCFURLConnectionDelegateWithOperationQueue::willSendRequest):
(WebCore::ResourceHandleCFURLConnectionDelegateWithOperationQueue::didReceiveResponse):
(WebCore::ResourceHandleCFURLConnectionDelegateWithOperationQueue::didReceiveData):
(WebCore::ResourceHandleCFURLConnectionDelegateWithOperationQueue::didFinishLoading):
(WebCore::ResourceHandleCFURLConnectionDelegateWithOperationQueue::didFail):
(WebCore::ResourceHandleCFURLConnectionDelegateWithOperationQueue::willCacheResponse):
(WebCore::ResourceHandleCFURLConnectionDelegateWithOperationQueue::didReceiveChallenge):
(WebCore::ResourceHandleCFURLConnectionDelegateWithOperationQueue::didSendBodyData):
(WebCore::ResourceHandleCFURLConnectionDelegateWithOperationQueue::shouldUseCredentialStorage):
(WebCore::ResourceHandleCFURLConnectionDelegateWithOperationQueue::canRespondToProtectionSpace):
(WebCore::ResourceHandleCFURLConnectionDelegateWithOperationQueue::continueCanAuthenticateAgainstProtectionSpace):

  • platform/network/cf/ResourceHandleCFURLConnectionDelegateWithOperationQueue.h:
  • platform/network/cf/SynchronousResourceHandleCFURLConnectionDelegate.cpp: Removed.
  • platform/network/cf/SynchronousResourceHandleCFURLConnectionDelegate.h: Removed.
  • platform/network/mac/ResourceHandleMac.mm:

(WebCore::ResourceHandle::start):
(WebCore::ResourceHandle::schedule):
(WebCore::ResourceHandle::makeDelegate):
(WebCore::ResourceHandle::delegate):
(WebCore::ResourceHandle::platformLoadResourceSynchronously):
(WebCore::ResourceHandle::willSendRequest):
(WebCore::ResourceHandle::continueWillSendRequest):
(WebCore::ResourceHandle::continueDidReceiveResponse):
(WebCore::ResourceHandle::canAuthenticateAgainstProtectionSpace):
(WebCore::ResourceHandle::continueCanAuthenticateAgainstProtectionSpace):
(WebCore::ResourceHandle::continueWillCacheResponse):
(WebCore::ResourceHandle::shouldUseCredentialStorage): Deleted.

  • platform/network/mac/WebCoreResourceHandleAsDelegate.h: Removed.
  • platform/network/mac/WebCoreResourceHandleAsDelegate.mm: Removed.
  • platform/network/mac/WebCoreResourceHandleAsOperationQueueDelegate.h:
  • platform/network/mac/WebCoreResourceHandleAsOperationQueueDelegate.mm:

(-[WebCoreResourceHandleAsOperationQueueDelegate connection:willSendRequest:redirectResponse:]):
(-[WebCoreResourceHandleAsOperationQueueDelegate connection:didReceiveAuthenticationChallenge:]):
(-[WebCoreResourceHandleAsOperationQueueDelegate connection:canAuthenticateAgainstProtectionSpace:]):
(-[WebCoreResourceHandleAsOperationQueueDelegate connection:didReceiveResponse:]):
(-[WebCoreResourceHandleAsOperationQueueDelegate connection:didReceiveData:lengthReceived:]):
(-[WebCoreResourceHandleAsOperationQueueDelegate connection:didSendBodyData:totalBytesWritten:totalBytesExpectedToWrite:]):
(-[WebCoreResourceHandleAsOperationQueueDelegate connection:didFailWithError:]):
(-[WebCoreResourceHandleAsOperationQueueDelegate connection:willCacheResponse:]):

Source/WebKitLegacy:

  • WebCoreSupport/WebResourceLoadScheduler.cpp:

(WebResourceLoadScheduler::createPingHandle):

Tools:

  • TestWebKitAPI/Tests/mac/SimplifyMarkup.mm:

(TestWebKitAPI::TEST):
The HTML being loaded contains an iframe, so testing if the main resource has loaded doesn't necessarily mean all subresources are loaded.
Wait until they are loaded before continuing the test. This is a test of editing commands once the page has loaded, not a test of loading.

LayoutTests:

  • TestExpectations:
  • platform/gtk/TestExpectations:
  • platform/ios-wk2/TestExpectations:
  • platform/mac-wk2/TestExpectations:
  • platform/wk2/TestExpectations:

http/tests/cache/iframe-304-crash.html used to deterministically record its didFinishLoading callback,
but only for WK1. It was marked as flaky for all WK2 ports. It is now flaky in WK1 because the order
of the testRunner.notifyDone call and the didFinishLoading logging is no longer deterministic with
asynchronous loading, but the test still verifies that there is no crash.

http/tests/security/cross-origin-modal-dialog-base.html does navigation during showModalDialog, which
probably should've never worked in WK1 and never worked in WK2. WK1 behavior now matches WK2 behavior.
I'm not aware of any complaints about no navigation working during showModalDialog in WK2 and I imagine
nobody will be regressed by this change, but if we do find such a problem, creative use of MessageQueues
like we do with sync xhr in WK1 now could theoretically fix the problem, but we are trying to get
rid of showModalDialog anyway. The test was written to verify that the SecurityOrigin doesn't fall back
to the wrong origin, and it certainly doesn't now.

These tests dump load delegate call order, which are less deterministic now but the tests still behave correctly.
http/tests/svg/svg-use-external.html
http/tests/loading/text-content-type-with-binary-extension.html
http/tests/security/contentSecurityPolicy/block-all-mixed-content/insecure-iframe-in-main-frame.html

Location:
trunk
Files:
4 deleted
52 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r224265 r224267  
     12017-10-31  Alex Christensen  <achristensen@webkit.org>
     2
     3        Use asynchronous ResourceHandleClient calls for WebKit1
     4        https://bugs.webkit.org/show_bug.cgi?id=160677
     5
     6        Reviewed by Brady Eidson.
     7
     8        * TestExpectations:
     9        * platform/gtk/TestExpectations:
     10        * platform/ios-wk2/TestExpectations:
     11        * platform/mac-wk2/TestExpectations:
     12        * platform/wk2/TestExpectations:
     13
     14        http/tests/cache/iframe-304-crash.html used to deterministically record its didFinishLoading callback,
     15        but only for WK1.  It was marked as flaky for all WK2 ports.  It is now flaky in WK1 because the order
     16        of the testRunner.notifyDone call and the didFinishLoading logging is no longer deterministic with
     17        asynchronous loading, but the test still verifies that there is no crash.
     18
     19        http/tests/security/cross-origin-modal-dialog-base.html does navigation during showModalDialog, which
     20        probably should've never worked in WK1 and never worked in WK2.  WK1 behavior now matches WK2 behavior.
     21        I'm not aware of any complaints about no navigation working during showModalDialog in WK2 and I imagine
     22        nobody will be regressed by this change, but if we do find such a problem, creative use of MessageQueues
     23        like we do with sync xhr in WK1 now could theoretically fix the problem, but we are trying to get
     24        rid of showModalDialog anyway.  The test was written to verify that the SecurityOrigin doesn't fall back
     25        to the wrong origin, and it certainly doesn't now.
     26
     27        These tests dump load delegate call order, which are less deterministic now but the tests still behave correctly.
     28        http/tests/svg/svg-use-external.html
     29        http/tests/loading/text-content-type-with-binary-extension.html
     30        http/tests/security/contentSecurityPolicy/block-all-mixed-content/insecure-iframe-in-main-frame.html
     31
    1322017-10-31  Simon Fraser  <simon.fraser@apple.com>
    233

  • trunk/LayoutTests/TestExpectations

    r224264 r224267  
    4141# window.showModalDialog is only tested in DumpRenderTree on Mac.
    4242editing/execCommand/show-modal-dialog-during-execCommand.html [ Skip ]
     43http/tests/security/cross-origin-modal-dialog-base.html [ Skip ]
     44fast/events/scroll-event-during-modal-dialog.html [ Skip ]
     45fast/harness/show-modal-dialog.html [ Skip ]
    4346
    4447fast/shadow-dom/touch-event-on-text-assigned-to-slot.html [ Skip ]
    … …  
    489492webkit.org/b/169565 imported/w3c/web-platform-tests/cors/status-async.htm [ Failure ]
    490493webkit.org/b/169565 imported/w3c/web-platform-tests/cors/304.htm [ Failure ]
     494
     495# These tests used to have deterministic load delegate callback order before webkit.org/b/160677
     496http/tests/svg/svg-use-external.html [ Pass Failure ]
     497http/tests/loading/text-content-type-with-binary-extension.html [ Pass Failure ]
     498http/tests/security/contentSecurityPolicy/block-all-mixed-content/insecure-iframe-in-main-frame.html [ Pass Failure ]
    491499
    492500# Tests that are flakey due to unhandled promise rejection error messages
    … …  
    826834webkit.org/b/140043 js/dom/Promise.html [ Pass Failure ]
    827835
     836webkit.org/b/134550 http/tests/cache/iframe-304-crash.html [ Failure Pass ]
    828837webkit.org/b/141267 http/tests/misc/detached-frame-console.html [ Pass Failure ]
    829838

  • trunk/LayoutTests/platform/gtk/TestExpectations

    r224234 r224267  
    16341634webkit.org/b/36642 fast/replaced/border-radius-clip.html [ Failure Pass Crash ]
    16351635
    1636 webkit.org/b/134550 http/tests/cache/iframe-304-crash.html [ Failure Pass ]
    1637 
    16381636webkit.org/b/134573 media/track/audio-track.html [ Failure Timeout Pass ]
    16391637webkit.org/b/134576 media/track/audio/audio-track-mkv-vorbis-language.html [ Failure Timeout Pass ]

  • trunk/LayoutTests/platform/ios-wk2/TestExpectations

    r224261 r224267  
    368368
    369369# HTTP tests that are flaky:
    370 http/tests/cache/iframe-304-crash.html [ Failure Pass ]
    371370http/tests/navigation/forward-and-cancel.html [ Failure Pass ]
    372371http/tests/security/xss-DENIED-xsl-external-entity-redirect.xml [ Failure Pass ]

  • trunk/LayoutTests/platform/mac-wk1/TestExpectations

    r224239 r224267  
    7474
    7575webkit.org/b/172092 [ Debug ] fast/parser/adoption-agency-unload-iframe-4.html [ Pass Timeout ]
     76
     77# webkit.org/b/178272
     78http/tests/media/video-redirect.html [ Pass Failure ]
     79http/tests/security/contentSecurityPolicy/audio-redirect-allowed.html [ Pass Failure ]
     80http/tests/security/contentSecurityPolicy/video-redirect-allowed.html [ Pass Failure ]
     81http/tests/security/contentSecurityPolicy/video-with-http-url-allowed-by-csp-media-src-star.html [ Pass Failure ]
     82http/tests/security/local-video-source-from-remote.html [ Pass Failure ]
     83http/tests/security/video-cross-origin-accesssameorigin.html [ Pass Failure ]
     84http/tests/canvas/webgl/origin-clean-conformance.html [ Pass Timeout ]
     85http/tests/media/autoplay-if-audio-is-playing.html [ Pass Timeout ]
     86http/tests/media/video-load-twice.html [ Pass Timeout ]
     87http/tests/media/video-play-progress.html [ Pass Timeout ]
     88http/tests/security/canvas-remote-read-remote-video-localhost.html [ Pass Timeout ]
     89http/tests/security/canvas-remote-read-remote-video-redirect.html [ Pass Timeout ]
     90http/tests/security/video-cross-origin-caching.html [ Pass Timeout ]
    7691
    7792### END OF (1) Failures with bug reports

  • trunk/LayoutTests/platform/mac-wk2/TestExpectations

    r224239 r224267  
    302302webkit.org/b/162999 accessibility/mac/wk1-set-selected-text-marker-range-input-element.html [ Skip ]
    303303
    304 webkit.org/b/134550 http/tests/cache/iframe-304-crash.html [ Pass Failure ]
    305 
    306304# testRunner.setUseDeferredFrameLoading is not implemented.
    307305webkit.org/b/93980 http/tests/appcache/load-from-appcache-defer-resume-crash.html [ Skip ]

  • trunk/LayoutTests/platform/wk2/TestExpectations

    r224025 r224267  
    265265fast/events/scroll-event-during-modal-dialog.html
    266266fast/harness/show-modal-dialog.html
    267 http/tests/security/cross-origin-modal-dialog-base.html [ Skip ]
    268267
    269268# WebKit2 needs to support synchronous creation of about:blank/data:url frames

  • trunk/LayoutTests/security/block-test.html

    r223408 r224267  
    6868        }
    6969    }
     70
     71    function makeImage() {
     72        var image = document.createElement("img");
     73        image.onerror=nextBlockedPortTest;
     74        image.src="http://255.255.255.255:1/test.jpg";
     75        image.id="testIMG";
     76        document.body.appendChild(image);
     77    }
    7078</script>
    71 <body>
     79<body onload="makeImage()">
    7280<p>This test attempts to change the src of an IMG tag to all black listed ports to confirm that WebKit returns the
    7381correct error for them - blocked instead of cannot find.  It also tries the FTP ports for exemptions.  Due to the
    7482nature of this test, the results can only be processed automatically via DumpRenderTree
    7583</p>
    76 <img id="testIMG" src="http://255.255.255.255:1/test.jpg" onError="nextBlockedPortTest();"></img>
    7784</body>
    7885</html>

  • trunk/LayoutTests/svg/in-html/by-reference.html

    r223408 r224267  
    55-->
    66<head>
     7    <script>
     8        if (window.testRunner)
     9            testRunner.waitUntilDone();
     10        var elementsLoaded = 0;
     11        function loaded() {
     12            if (window.testRunner && ++elementsLoaded == 5)
     13                testRunner.notifyDone();
     14        }
     15    </script>
    716  <style type='text/css'>
    817    * {
    … …  
    2231<body>
    2332  <div>
    24     <object type='image/svg+xml' width='50' height='50' data='data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIj8+Cjxzdmcgd2lkdGg9IjUwIiBoZWlnaHQ9IjUwIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciLz4='></object>
    25     <embed width='50' height='50' src='data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIj8+Cjxzdmcgd2lkdGg9IjUwIiBoZWlnaHQ9IjUwIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciLz4='></embed>
    26     <iframe width='100' height='100' src='data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIj8+Cjxzdmcgd2lkdGg9IjUwIiBoZWlnaHQ9IjUwIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciLz4='></iframe>
    27     <object type='text/xml' width='50' height='50' data='data:text/xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIj8+Cjxzdmcgd2lkdGg9IjUwIiBoZWlnaHQ9IjUwIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciLz4='></object>
    28     <object type='application/xml' width='50' height='50' data='data:application/xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIj8+Cjxzdmcgd2lkdGg9IjUwIiBoZWlnaHQ9IjUwIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciLz4='></object-->
     33    <object onload="loaded()" type='image/svg+xml' width='50' height='50' data='data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIj8+Cjxzdmcgd2lkdGg9IjUwIiBoZWlnaHQ9IjUwIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciLz4='></object>
     34    <embed onload="loaded()" width='50' height='50' src='data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIj8+Cjxzdmcgd2lkdGg9IjUwIiBoZWlnaHQ9IjUwIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciLz4='></embed>
     35    <iframe onload="loaded()" width='100' height='100' src='data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIj8+Cjxzdmcgd2lkdGg9IjUwIiBoZWlnaHQ9IjUwIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciLz4='></iframe>
     36    <object onload="loaded()" type='text/xml' width='50' height='50' data='data:text/xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIj8+Cjxzdmcgd2lkdGg9IjUwIiBoZWlnaHQ9IjUwIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciLz4='></object>
     37    <object onload="loaded()" type='application/xml' width='50' height='50' data='data:application/xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIj8+Cjxzdmcgd2lkdGg9IjUwIiBoZWlnaHQ9IjUwIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciLz4='></object-->
    2938  </div>
    3039</body>

  • trunk/Source/WebCore/ChangeLog

    r224265 r224267  
     12017-10-31  Alex Christensen  <achristensen@webkit.org>
     2
     3        Use asynchronous ResourceHandleClient calls for WebKit1
     4        https://bugs.webkit.org/show_bug.cgi?id=160677
     5
     6        Reviewed by Brady Eidson.
     7
     8        Covered by existing tests.
     9
     10        * PlatformAppleWin.cmake:
     11        * PlatformMac.cmake:
     12        * WebCore.xcodeproj/project.pbxproj:
     13        * loader/ResourceLoader.cpp:
     14        (WebCore::ResourceLoader::willSendRequestAsync):
     15        (WebCore::ResourceLoader::didReceiveResponseAsync):
     16        (WebCore::ResourceLoader::canAuthenticateAgainstProtectionSpaceAsync):
     17        * loader/ResourceLoader.h:
     18        * loader/appcache/ApplicationCacheGroup.cpp:
     19        (WebCore::ApplicationCacheGroup::didReceiveResponseAsync):
     20        (WebCore::ApplicationCacheGroup::willSendRequestAsync):
     21        (WebCore::ApplicationCacheGroup::canAuthenticateAgainstProtectionSpaceAsync):
     22        (WebCore::ApplicationCacheGroup::didReceiveResponse): Deleted.
     23        * loader/appcache/ApplicationCacheGroup.h:
     24        * platform/network/BlobResourceHandle.cpp:
     25        (WebCore::BlobResourceHandle::continueDidReceiveResponse):
     26        (WebCore::BlobResourceHandle::getSizeForNext):
     27        (WebCore::BlobResourceHandle::notifyResponseOnSuccess):
     28        (WebCore::BlobResourceHandle::notifyResponseOnError):
     29        * platform/network/PingHandle.h:
     30        * platform/network/ResourceHandle.cpp:
     31        (WebCore::ResourceHandle::didReceiveResponse):
     32        (WebCore::ResourceHandle::usesAsyncCallbacks): Deleted.
     33        * platform/network/ResourceHandle.h:
     34        * platform/network/ResourceHandleClient.cpp:
     35        (WebCore::ResourceHandleClient::~ResourceHandleClient):
     36        (WebCore::ResourceHandleClient::willSendRequest): Deleted.
     37        (WebCore::ResourceHandleClient::willSendRequestAsync): Deleted.
     38        (WebCore::ResourceHandleClient::didReceiveResponseAsync): Deleted.
     39        (WebCore::ResourceHandleClient::canAuthenticateAgainstProtectionSpaceAsync): Deleted.
     40        * platform/network/ResourceHandleClient.h:
     41        (WebCore::ResourceHandleClient::didReceiveAuthenticationChallenge):
     42        (WebCore::ResourceHandleClient::didReceiveResponse): Deleted.
     43        (WebCore::ResourceHandleClient::usesAsyncCallbacks): Deleted.
     44        (WebCore::ResourceHandleClient::canAuthenticateAgainstProtectionSpace): Deleted.
     45        * platform/network/ResourceHandleInternal.h:
     46        (WebCore::ResourceHandleInternal::ResourceHandleInternal):
     47        * platform/network/SynchronousLoaderClient.cpp:
     48        (WebCore::SynchronousLoaderClient::willSendRequestAsync):
     49        (WebCore::SynchronousLoaderClient::canAuthenticateAgainstProtectionSpaceAsync):
     50        (WebCore::SynchronousLoaderClient::didReceiveResponseAsync):
     51        (WebCore::SynchronousLoaderClient::didFinishLoading):
     52        (WebCore::SynchronousLoaderClient::didFail):
     53        (WebCore::SynchronousLoaderClient::willSendRequest): Deleted.
     54        (WebCore::SynchronousLoaderClient::canAuthenticateAgainstProtectionSpace): Deleted.
     55        (WebCore::SynchronousLoaderClient::didReceiveResponse): Deleted.
     56        * platform/network/SynchronousLoaderClient.h:
     57        * platform/network/cf/ResourceHandleCFNet.cpp:
     58        (WebCore::ResourceHandle::createCFURLConnection):
     59        (WebCore::ResourceHandle::start):
     60        (WebCore::ResourceHandle::willSendRequest):
     61        (WebCore::ResourceHandle::shouldUseCredentialStorage):
     62        (WebCore::ResourceHandle::canAuthenticateAgainstProtectionSpace):
     63        (WebCore::ResourceHandle::platformLoadResourceSynchronously):
     64        * platform/network/cf/ResourceHandleCFURLConnectionDelegateWithOperationQueue.cpp:
     65        (WebCore::ResourceHandleCFURLConnectionDelegateWithOperationQueue::ResourceHandleCFURLConnectionDelegateWithOperationQueue):
     66        (WebCore::ResourceHandleCFURLConnectionDelegateWithOperationQueue::releaseHandle):
     67        (WebCore::ResourceHandleCFURLConnectionDelegateWithOperationQueue::willSendRequest):
     68        (WebCore::ResourceHandleCFURLConnectionDelegateWithOperationQueue::didReceiveResponse):
     69        (WebCore::ResourceHandleCFURLConnectionDelegateWithOperationQueue::didReceiveData):
     70        (WebCore::ResourceHandleCFURLConnectionDelegateWithOperationQueue::didFinishLoading):
     71        (WebCore::ResourceHandleCFURLConnectionDelegateWithOperationQueue::didFail):
     72        (WebCore::ResourceHandleCFURLConnectionDelegateWithOperationQueue::willCacheResponse):
     73        (WebCore::ResourceHandleCFURLConnectionDelegateWithOperationQueue::didReceiveChallenge):
     74        (WebCore::ResourceHandleCFURLConnectionDelegateWithOperationQueue::didSendBodyData):
     75        (WebCore::ResourceHandleCFURLConnectionDelegateWithOperationQueue::shouldUseCredentialStorage):
     76        (WebCore::ResourceHandleCFURLConnectionDelegateWithOperationQueue::canRespondToProtectionSpace):
     77        (WebCore::ResourceHandleCFURLConnectionDelegateWithOperationQueue::continueCanAuthenticateAgainstProtectionSpace):
     78        * platform/network/cf/ResourceHandleCFURLConnectionDelegateWithOperationQueue.h:
     79        * platform/network/cf/SynchronousResourceHandleCFURLConnectionDelegate.cpp: Removed.
     80        * platform/network/cf/SynchronousResourceHandleCFURLConnectionDelegate.h: Removed.
     81        * platform/network/mac/ResourceHandleMac.mm:
     82        (WebCore::ResourceHandle::start):
     83        (WebCore::ResourceHandle::schedule):
     84        (WebCore::ResourceHandle::makeDelegate):
     85        (WebCore::ResourceHandle::delegate):
     86        (WebCore::ResourceHandle::platformLoadResourceSynchronously):
     87        (WebCore::ResourceHandle::willSendRequest):
     88        (WebCore::ResourceHandle::continueWillSendRequest):
     89        (WebCore::ResourceHandle::continueDidReceiveResponse):
     90        (WebCore::ResourceHandle::canAuthenticateAgainstProtectionSpace):
     91        (WebCore::ResourceHandle::continueCanAuthenticateAgainstProtectionSpace):
     92        (WebCore::ResourceHandle::continueWillCacheResponse):
     93        (WebCore::ResourceHandle::shouldUseCredentialStorage): Deleted.
     94        * platform/network/mac/WebCoreResourceHandleAsDelegate.h: Removed.
     95        * platform/network/mac/WebCoreResourceHandleAsDelegate.mm: Removed.
     96        * platform/network/mac/WebCoreResourceHandleAsOperationQueueDelegate.h:
     97        * platform/network/mac/WebCoreResourceHandleAsOperationQueueDelegate.mm:
     98        (-[WebCoreResourceHandleAsOperationQueueDelegate connection:willSendRequest:redirectResponse:]):
     99        (-[WebCoreResourceHandleAsOperationQueueDelegate connection:didReceiveAuthenticationChallenge:]):
     100        (-[WebCoreResourceHandleAsOperationQueueDelegate connection:canAuthenticateAgainstProtectionSpace:]):
     101        (-[WebCoreResourceHandleAsOperationQueueDelegate connection:didReceiveResponse:]):
     102        (-[WebCoreResourceHandleAsOperationQueueDelegate connection:didReceiveData:lengthReceived:]):
     103        (-[WebCoreResourceHandleAsOperationQueueDelegate connection:didSendBodyData:totalBytesWritten:totalBytesExpectedToWrite:]):
     104        (-[WebCoreResourceHandleAsOperationQueueDelegate connection:didFailWithError:]):
     105        (-[WebCoreResourceHandleAsOperationQueueDelegate connection:willCacheResponse:]):
     106
    11072017-10-31  Simon Fraser  <simon.fraser@apple.com>
    2108

  • trunk/Source/WebCore/PlatformAppleWin.cmake

    r223476 r224267  
    6060    platform/network/cf/ResourceHandleCFNet.cpp
    6161    platform/network/cf/ResourceHandleCFURLConnectionDelegate.cpp
     62    platform/network/cf/ResourceHandleCFURLConnectionDelegateWithOperationQueue.cpp
    6263    platform/network/cf/ResourceRequestCFNet.cpp
    6364    platform/network/cf/ResourceResponseCFNet.cpp
    6465    platform/network/cf/SocketStreamHandleImplCFNet.cpp
    6566    platform/network/cf/SynchronousLoaderClientCFNet.cpp
    66     platform/network/cf/SynchronousResourceHandleCFURLConnectionDelegate.cpp
    6767)
    6868

  • trunk/Source/WebCore/PlatformMac.cmake

    r224008 r224267  
    480480    platform/network/mac/SynchronousLoaderClient.mm
    481481    platform/network/mac/UTIUtilities.mm
    482     platform/network/mac/WebCoreResourceHandleAsDelegate.mm
    483482    platform/network/mac/WebCoreResourceHandleAsOperationQueueDelegate.mm
    484483    platform/network/mac/WebCoreURLResponse.mm

  • trunk/Source/WebCore/SourcesCocoa.txt

    r224123 r224267  
    331331platform/network/cf/SocketStreamHandleImplCFNet.cpp
    332332platform/network/cf/SynchronousLoaderClientCFNet.cpp
    333 platform/network/cf/SynchronousResourceHandleCFURLConnectionDelegate.cpp
    334333
    335334platform/network/cocoa/CookieCocoa.mm
    … …  
    354353platform/network/mac/SynchronousLoaderClient.mm
    355354platform/network/mac/UTIUtilities.mm
    356 platform/network/mac/WebCoreResourceHandleAsDelegate.mm
    357355platform/network/mac/WebCoreResourceHandleAsOperationQueueDelegate.mm
    358356platform/network/mac/WebCoreURLResponse.mm

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r224255 r224267  
    672672                26FAE4CC1852E3A5004C8C46 /* ResourceHandleCFURLConnectionDelegate.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26FAE4C81852E3A5004C8C46 /* ResourceHandleCFURLConnectionDelegate.cpp */; };
    673673                26FAE4CD1852E3A5004C8C46 /* ResourceHandleCFURLConnectionDelegate.h in Headers */ = {isa = PBXBuildFile; fileRef = 26FAE4C91852E3A5004C8C46 /* ResourceHandleCFURLConnectionDelegate.h */; };
    674                 26FAE4CF1852E3A5004C8C46 /* SynchronousResourceHandleCFURLConnectionDelegate.h in Headers */ = {isa = PBXBuildFile; fileRef = 26FAE4CB1852E3A5004C8C46 /* SynchronousResourceHandleCFURLConnectionDelegate.h */; };
    675674                2914E3081CAB5A440049966F /* AccessibilityAttachment.h in Headers */ = {isa = PBXBuildFile; fileRef = 2914E3061CAB5A440049966F /* AccessibilityAttachment.h */; };
    676675                2917B5621473496C0052C9D0 /* LayerFlushScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = 2917B55F1473496C0052C9D0 /* LayerFlushScheduler.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    44324431                E17B491616A9B094001C8839 /* TransitionEvent.h in Headers */ = {isa = PBXBuildFile; fileRef = E17B491416A9B093001C8839 /* TransitionEvent.h */; };
    44334432                E17B492116A9B8FF001C8839 /* JSTransitionEvent.h in Headers */ = {isa = PBXBuildFile; fileRef = E17B491F16A9B8FF001C8839 /* JSTransitionEvent.h */; };
    4434                 E180810F16FCECDF00B80D07 /* WebCoreResourceHandleAsDelegate.h in Headers */ = {isa = PBXBuildFile; fileRef = E180810D16FCECDF00B80D07 /* WebCoreResourceHandleAsDelegate.h */; };
    44354433                E180811716FCF9CB00B80D07 /* SynchronousLoaderClient.h in Headers */ = {isa = PBXBuildFile; fileRef = E180811516FCF9CB00B80D07 /* SynchronousLoaderClient.h */; settings = {ATTRIBUTES = (Private, ); }; };
    44364434                E18256900EF2B02D00933242 /* JSWorkerGlobalScope.h in Headers */ = {isa = PBXBuildFile; fileRef = E182568E0EF2B02D00933242 /* JSWorkerGlobalScope.h */; };
    … …  
    61386136                26FAE4C81852E3A5004C8C46 /* ResourceHandleCFURLConnectionDelegate.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ResourceHandleCFURLConnectionDelegate.cpp; sourceTree = "<group>"; };
    61396137                26FAE4C91852E3A5004C8C46 /* ResourceHandleCFURLConnectionDelegate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ResourceHandleCFURLConnectionDelegate.h; sourceTree = "<group>"; };
    6140                 26FAE4CA1852E3A5004C8C46 /* SynchronousResourceHandleCFURLConnectionDelegate.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SynchronousResourceHandleCFURLConnectionDelegate.cpp; sourceTree = "<group>"; };
    6141                 26FAE4CB1852E3A5004C8C46 /* SynchronousResourceHandleCFURLConnectionDelegate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SynchronousResourceHandleCFURLConnectionDelegate.h; sourceTree = "<group>"; };
    61426138                2914E3051CAB5A440049966F /* AccessibilityAttachment.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = AccessibilityAttachment.cpp; sourceTree = "<group>"; };
    61436139                2914E3061CAB5A440049966F /* AccessibilityAttachment.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AccessibilityAttachment.h; sourceTree = "<group>"; };
    … …  
    1357413570                E17B491F16A9B8FF001C8839 /* JSTransitionEvent.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSTransitionEvent.h; sourceTree = "<group>"; };
    1357513571                E17B492016A9B8FF001C8839 /* JSTransitionEvent.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSTransitionEvent.cpp; sourceTree = "<group>"; };
    13576                 E180810C16FCECDF00B80D07 /* WebCoreResourceHandleAsDelegate.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WebCoreResourceHandleAsDelegate.mm; sourceTree = "<group>"; };
    13577                 E180810D16FCECDF00B80D07 /* WebCoreResourceHandleAsDelegate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebCoreResourceHandleAsDelegate.h; sourceTree = "<group>"; };
    1357813572                E180811016FCF42E00B80D07 /* SynchronousLoaderClient.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SynchronousLoaderClient.cpp; sourceTree = "<group>"; };
    1357913573                E180811416FCF9CB00B80D07 /* SynchronousLoaderClient.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = SynchronousLoaderClient.mm; sourceTree = "<group>"; };
    … …  
    1825118245                                1FAFBF1615A5FA5200083A20 /* UTIUtilities.h */,
    1825218246                                1FAFBF1715A5FA5200083A20 /* UTIUtilities.mm */,
    18253                                 E180810D16FCECDF00B80D07 /* WebCoreResourceHandleAsDelegate.h */,
    18254                                 E180810C16FCECDF00B80D07 /* WebCoreResourceHandleAsDelegate.mm */,
    1825518247                                E152551316FD234F003D7ADB /* WebCoreResourceHandleAsOperationQueueDelegate.h */,
    1825618248                                E152551416FD234F003D7ADB /* WebCoreResourceHandleAsOperationQueueDelegate.mm */,
    … …  
    2281422806                                51ABAE1D103C1913008C5260 /* SocketStreamHandleImplCFNet.cpp */,
    2281522807                                442ABCD517D9262F00D30715 /* SynchronousLoaderClientCFNet.cpp */,
    22816                                 26FAE4CA1852E3A5004C8C46 /* SynchronousResourceHandleCFURLConnectionDelegate.cpp */,
    22817                                 26FAE4CB1852E3A5004C8C46 /* SynchronousResourceHandleCFURLConnectionDelegate.h */,
    2281822808                        );
    2281922809                        path = cf;
    … …  
    2930229292                                517A53461F50C17F00DCDC0A /* SWServerWorker.h in Headers */,
    2930329293                                E180811716FCF9CB00B80D07 /* SynchronousLoaderClient.h in Headers */,
    29304                                 26FAE4CF1852E3A5004C8C46 /* SynchronousResourceHandleCFURLConnectionDelegate.h in Headers */,
    2930529294                                0F03C0741884695E00A5F8CA /* SystemMemory.h in Headers */,
    2930629295                                5D5975B319635F1100D00878 /* SystemVersion.h in Headers */,
    … …  
    2953729526                                DD05FE0D0B8BA3C6009ACDFE /* WebCoreObjCExtras.h in Headers */,
    2953829527                                EDEC98030AED7E170059137F /* WebCorePrefix.h in Headers */,
    29539                                 E180810F16FCECDF00B80D07 /* WebCoreResourceHandleAsDelegate.h in Headers */,
    2954029528                                E152551516FD2350003D7ADB /* WebCoreResourceHandleAsOperationQueueDelegate.h in Headers */,
    2954129529                                A14832C7187F66C800DA63A6 /* WebCoreThread.h in Headers */,

  • trunk/Source/WebCore/editing/cocoa/WebArchiveResourceFromNSAttributedString.mm

    r223408 r224267  
    4343    }
    4444
    45     resource = ArchiveResource::create(SharedBuffer::create(adoptNS([data copy]).get()), URL, MIMEType, textEncodingName, frameName, nil);
     45    resource = ArchiveResource::create(SharedBuffer::create(adoptNS([data copy]).get()), URL, MIMEType, textEncodingName, frameName, { });
    4646    if (!resource) {
    4747        [self release];

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

    r224134 r224267  
    639639}
    640640
    641 ResourceRequest ResourceLoader::willSendRequest(ResourceHandle*, ResourceRequest&& request, ResourceResponse&& redirectResponse)
    642 {
    643     if (documentLoader()->applicationCacheHost().maybeLoadFallbackForRedirect(this, request, redirectResponse))
    644         return WTFMove(request);
     641void ResourceLoader::willSendRequestAsync(ResourceHandle* handle, ResourceRequest&& request, ResourceResponse&& redirectResponse)
     642{
     643    RefPtr<ResourceHandle> protectedHandle(handle);
     644    if (documentLoader()->applicationCacheHost().maybeLoadFallbackForRedirect(this, request, redirectResponse)) {
     645        handle->continueWillSendRequest(WTFMove(request));
     646        return;
     647    }
    645648    willSendRequestInternal(request, redirectResponse);
    646     return WTFMove(request);
     649    handle->continueWillSendRequest(WTFMove(request));
    647650}
    648651
    … …  
    652655}
    653656
    654 void ResourceLoader::didReceiveResponse(ResourceHandle*, ResourceResponse&& response)
    655 {
    656     if (documentLoader()->applicationCacheHost().maybeLoadFallbackForResponse(this, response))
    657         return;
     657void ResourceLoader::didReceiveResponseAsync(ResourceHandle* handle, ResourceResponse&& response)
     658{
     659    if (documentLoader()->applicationCacheHost().maybeLoadFallbackForResponse(this, response)) {
     660        handle->continueDidReceiveResponse();
     661        return;
     662    }
    658663    didReceiveResponse(response);
     664    handle->continueDidReceiveResponse();
    659665}
    660666
    … …  
    727733
    728734#if USE(PROTECTION_SPACE_AUTH_CALLBACK)
     735void ResourceLoader::canAuthenticateAgainstProtectionSpaceAsync(ResourceHandle* handle, const ProtectionSpace& protectionSpace)
     736{
     737    handle->continueCanAuthenticateAgainstProtectionSpace(canAuthenticateAgainstProtectionSpace(protectionSpace));
     738}
    729739
    730740bool ResourceLoader::canAuthenticateAgainstProtectionSpace(const ProtectionSpace& protectionSpace)

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

    r224134 r224267  
    185185
    186186    // ResourceHandleClient
    187     ResourceRequest willSendRequest(ResourceHandle*, ResourceRequest&&, ResourceResponse&& redirectResponse) override;
    188187    void didSendData(ResourceHandle*, unsigned long long bytesSent, unsigned long long totalBytesToBeSent) override;
    189     void didReceiveResponse(ResourceHandle*, ResourceResponse&&) override;
     188    void didReceiveResponseAsync(ResourceHandle*, ResourceResponse&&) override;
     189    void willSendRequestAsync(ResourceHandle*, ResourceRequest&&, ResourceResponse&&) override;
    190190    void didReceiveData(ResourceHandle*, const char*, unsigned, int encodedDataLength) override;
    191191    void didReceiveBuffer(ResourceHandle*, Ref<SharedBuffer>&&, int encodedDataLength) override;
    … …  
    197197    void didReceiveAuthenticationChallenge(ResourceHandle*, const AuthenticationChallenge& challenge) override { didReceiveAuthenticationChallenge(challenge); }
    198198#if USE(PROTECTION_SPACE_AUTH_CALLBACK)
    199     bool canAuthenticateAgainstProtectionSpace(ResourceHandle*, const ProtectionSpace& protectionSpace) override { return canAuthenticateAgainstProtectionSpace(protectionSpace); }
     199    void canAuthenticateAgainstProtectionSpaceAsync(ResourceHandle*, const ProtectionSpace&) override;
    200200#endif
    201201    void receivedCancellation(ResourceHandle*, const AuthenticationChallenge& challenge) override { receivedCancellation(challenge); }

  • trunk/Source/WebCore/loader/appcache/ApplicationCacheGroup.cpp

    r223408 r224267  
    486486}
    487487
    488 void ApplicationCacheGroup::didReceiveResponse(ResourceHandle* handle, ResourceResponse&& response)
     488void ApplicationCacheGroup::didReceiveResponseAsync(ResourceHandle* handle, ResourceResponse&& response)
    489489{
    490490    ASSERT(m_frame);
    … …  
    493493    if (handle == m_manifestHandle) {
    494494        didReceiveManifestResponse(response);
     495        handle->continueDidReceiveResponse();
    495496        return;
    496497    }
    … …  
    519520            // Load the next resource, if any.
    520521            startLoadingEntry();
     522            handle->continueDidReceiveResponse();
    521523            return;
    522524        }
    … …  
    550552            startLoadingEntry();
    551553        }
     554        handle->continueDidReceiveResponse();
    552555        return;
    553556    }
    554557   
    555558    m_currentResource = ApplicationCacheResource::create(url, response, type);
    556 }
     559    handle->continueDidReceiveResponse();
     560}
     561
     562void ApplicationCacheGroup::willSendRequestAsync(ResourceHandle* handle, ResourceRequest&& request, ResourceResponse&&)
     563{
     564    handle->continueWillSendRequest(WTFMove(request));
     565}
     566
     567#if USE(PROTECTION_SPACE_AUTH_CALLBACK)
     568void ApplicationCacheGroup::canAuthenticateAgainstProtectionSpaceAsync(ResourceHandle* handle, const ProtectionSpace&)
     569{
     570    handle->continueCanAuthenticateAgainstProtectionSpace(false);
     571}
     572#endif
    557573
    558574void ApplicationCacheGroup::didReceiveData(ResourceHandle* handle, const char* data, unsigned length, int encodedDataLength)

  • trunk/Source/WebCore/loader/appcache/ApplicationCacheGroup.h

    r223408 r224267  
    110110
    111111    // ResourceHandleClient
    112     void didReceiveResponse(ResourceHandle*, ResourceResponse&&) override;
    113     void didReceiveData(ResourceHandle*, const char*, unsigned length, int encodedDataLength) override;
    114     void didFinishLoading(ResourceHandle*) override;
    115     void didFail(ResourceHandle*, const ResourceError&) override;
     112    void didReceiveResponseAsync(ResourceHandle*, ResourceResponse&&) final;
     113    void willSendRequestAsync(ResourceHandle*, ResourceRequest&&, ResourceResponse&&) final;
     114#if USE(PROTECTION_SPACE_AUTH_CALLBACK)
     115    void canAuthenticateAgainstProtectionSpaceAsync(ResourceHandle*, const ProtectionSpace&) final;
     116#endif
     117    void didReceiveData(ResourceHandle*, const char*, unsigned length, int encodedDataLength) final;
     118    void didFinishLoading(ResourceHandle*) final;
     119    void didFail(ResourceHandle*, const ResourceError&) final;
    116120
    117121    void didReceiveManifestResponse(const ResourceResponse&);

  • trunk/Source/WebCore/platform/network/BlobResourceHandle.cpp

    r223728 r224267  
    7575    BlobResourceSynchronousLoader(ResourceError&, ResourceResponse&, Vector<char>&);
    7676
    77     void didReceiveResponse(ResourceHandle*, ResourceResponse&&) override;
    78     void didFail(ResourceHandle*, const ResourceError&) override;
     77    void didReceiveResponseAsync(ResourceHandle*, ResourceResponse&&) final;
     78    void didFail(ResourceHandle*, const ResourceError&) final;
     79    void willSendRequestAsync(ResourceHandle*, ResourceRequest&&, ResourceResponse&&) final;
     80#if USE(PROTECTION_SPACE_AUTH_CALLBACK)
     81    void canAuthenticateAgainstProtectionSpaceAsync(ResourceHandle*, const ProtectionSpace&) final;
     82#endif
    7983
    8084private:
    … …  
    9195}
    9296
    93 void BlobResourceSynchronousLoader::didReceiveResponse(ResourceHandle* handle, ResourceResponse&& response)
     97void BlobResourceSynchronousLoader::willSendRequestAsync(ResourceHandle* handle, ResourceRequest&& request, ResourceResponse&&)
     98{
     99    ASSERT_NOT_REACHED();
     100    handle->continueWillSendRequest(WTFMove(request));
     101}
     102
     103#if USE(PROTECTION_SPACE_AUTH_CALLBACK)
     104void BlobResourceSynchronousLoader::canAuthenticateAgainstProtectionSpaceAsync(ResourceHandle* handle, const ProtectionSpace&)
     105{
     106    ASSERT_NOT_REACHED();
     107    handle->continueCanAuthenticateAgainstProtectionSpace(false);
     108}
     109#endif
     110
     111void BlobResourceSynchronousLoader::didReceiveResponseAsync(ResourceHandle* handle, ResourceResponse&& response)
    94112{
    95113    // We cannot handle the size that is more than maximum integer.
    96114    if (response.expectedContentLength() > INT_MAX) {
    97115        m_error = ResourceError(webKitBlobResourceDomain, static_cast<int>(BlobResourceHandle::Error::NotReadableError), response.url(), "File is too large");
     116        handle->continueDidReceiveResponse();
    98117        return;
    99118    }
    … …  
    104123    m_data.resize(static_cast<size_t>(response.expectedContentLength()));
    105124    static_cast<BlobResourceHandle*>(handle)->readSync(m_data.data(), static_cast<int>(m_data.size()));
     125    handle->continueDidReceiveResponse();
    106126}
    107127
    … …  
    158178void BlobResourceHandle::continueDidReceiveResponse()
    159179{
    160     ASSERT(m_async);
    161     ASSERT(usesAsyncCallbacks());
    162 
    163180    m_buffer.resize(bufferSize);
    164181    readAsync();
    … …  
    227244            Ref<BlobResourceHandle> protectedThis(*this);
    228245            notifyResponse();
    229             if (!usesAsyncCallbacks()) {
    230                 m_buffer.resize(bufferSize);
    231                 readAsync();
    232             }
    233246        }
    234247        return;
    … …  
    421434{
    422435    ASSERT(isMainThread());
    423     ASSERT(m_async);
    424436
    425437    // Do not continue if the request is aborted or an error occurs.
    … …  
    445457{
    446458    ASSERT(isMainThread());
    447     ASSERT(m_async);
    448459    ASSERT(item.data().data());
    449460
    … …  
    460471{
    461472    ASSERT(isMainThread());
    462     ASSERT(m_async);
    463473
    464474    if (m_fileOpened) {
    … …  
    574584    // Notably, this will affect a name suggested in "File Save As".
    575585
    576     didReceiveResponse(WTFMove(response));
     586    client()->didReceiveResponseAsync(this, WTFMove(response));
    577587}
    578588
    … …  
    597607    }
    598608
    599     didReceiveResponse(WTFMove(response));
     609    client()->didReceiveResponseAsync(this, WTFMove(response));
    600610}
    601611

  • trunk/Source/WebCore/platform/network/PingHandle.h

    r223408 r224267  
    4040    WTF_MAKE_NONCOPYABLE(PingHandle); WTF_MAKE_FAST_ALLOCATED;
    4141public:
    42     enum class UsesAsyncCallbacks {
    43         Yes,
    44         No,
    45     };
    46    
    47     PingHandle(NetworkingContext* networkingContext, const ResourceRequest& request, bool shouldUseCredentialStorage, UsesAsyncCallbacks useAsyncCallbacks, bool shouldFollowRedirects, WTF::CompletionHandler<void(const ResourceError&, const ResourceResponse&)>&& completionHandler)
     42    PingHandle(NetworkingContext* networkingContext, const ResourceRequest& request, bool shouldUseCredentialStorage, bool shouldFollowRedirects, WTF::CompletionHandler<void(const ResourceError&, const ResourceResponse&)>&& completionHandler)
    4843        : m_currentRequest(request)
    4944        , m_timeoutTimer(*this, &PingHandle::timeoutTimerFired)
    5045        , m_shouldUseCredentialStorage(shouldUseCredentialStorage)
    5146        , m_shouldFollowRedirects(shouldFollowRedirects)
    52         , m_usesAsyncCallbacks(useAsyncCallbacks)
    5347        , m_completionHandler(WTFMove(completionHandler))
    5448    {
    … …  
    6155
    6256private:
    63     ResourceRequest willSendRequest(ResourceHandle*, ResourceRequest&& request, ResourceResponse&&) final
    64     {
    65         return m_shouldFollowRedirects ? request : ResourceRequest();
    66     }
    67     void willSendRequestAsync(ResourceHandle* handle, ResourceRequest&& request, ResourceResponse&&) final
     57    void willSendRequestAsync(ResourceHandle*, ResourceRequest&& request, ResourceResponse&&) final
    6858    {
    6959        m_currentRequest = WTFMove(request);
    7060        if (m_shouldFollowRedirects) {
    71             handle->continueWillSendRequest(ResourceRequest { m_currentRequest });
     61            m_handle->continueWillSendRequest(ResourceRequest { m_currentRequest });
    7262            return;
    7363        }
     64        m_handle->continueWillSendRequest({ });
    7465        pingLoadComplete(ResourceError { String(), 0, m_currentRequest.url(), ASCIILiteral("Not allowed to follow redirects"), ResourceError::Type::AccessControl });
    7566    }
    76     void didReceiveResponse(ResourceHandle*, ResourceResponse&& response) final { pingLoadComplete({ }, response); }
     67    void didReceiveResponseAsync(ResourceHandle*, ResourceResponse&& response) final
     68    {
     69        m_handle->continueDidReceiveResponse();
     70        pingLoadComplete({ }, response);
     71    }
    7772    void didReceiveBuffer(ResourceHandle*, Ref<SharedBuffer>&&, int) final { pingLoadComplete(); }
    7873    void didFinishLoading(ResourceHandle*) final { pingLoadComplete(); }
    7974    void didFail(ResourceHandle*, const ResourceError& error) final { pingLoadComplete(error); }
    8075    bool shouldUseCredentialStorage(ResourceHandle*) final { return m_shouldUseCredentialStorage; }
    81     bool usesAsyncCallbacks() final { return m_usesAsyncCallbacks == UsesAsyncCallbacks::Yes; }
    8276    void timeoutTimerFired() { pingLoadComplete(ResourceError { String(), 0, m_currentRequest.url(), ASCIILiteral("Load timed out"), ResourceError::Type::Timeout }); }
     77#if USE(PROTECTION_SPACE_AUTH_CALLBACK)
     78    void canAuthenticateAgainstProtectionSpaceAsync(ResourceHandle*, const ProtectionSpace&)
     79    {
     80        m_handle->continueCanAuthenticateAgainstProtectionSpace(false);
     81        delete this;
     82    }
     83#endif
    8384
    8485    void pingLoadComplete(const ResourceError& error = { }, const ResourceResponse& response = { })
    … …  
    104105    bool m_shouldUseCredentialStorage;
    105106    bool m_shouldFollowRedirects;
    106     UsesAsyncCallbacks m_usesAsyncCallbacks;
    107107    WTF::CompletionHandler<void(const ResourceError&, const ResourceResponse&)> m_completionHandler;
    108108};

  • trunk/Source/WebCore/platform/network/ResourceHandle.cpp

    r223408 r224267  
    160160            String message = "Cancelled load from '" + url.stringCenterEllipsizedToLength() + "' because it is using HTTP/0.9.";
    161161            d->m_client->didFail(this, { String(), 0, url, message });
     162            continueDidReceiveResponse();
    162163            return;
    163164        }
    164165    }
    165     if (d->m_usesAsyncCallbacks)
    166         d->m_client->didReceiveResponseAsync(this, WTFMove(response));
    167     else {
    168         d->m_client->didReceiveResponse(this, WTFMove(response));
    169         platformContinueSynchronousDidReceiveResponse();
    170     }
     166    client()->didReceiveResponseAsync(this, WTFMove(response));
    171167}
    172168
    … …  
    245241}
    246242
    247 bool ResourceHandle::usesAsyncCallbacks() const
    248 {
    249     return d->m_usesAsyncCallbacks;
    250 }
    251 
    252243} // namespace WebCore

  • trunk/Source/WebCore/platform/network/ResourceHandle.h

    r223408 r224267  
    7171namespace WTF {
    7272class SchedulePair;
     73template<typename T> class MessageQueue;
    7374}
    7475
    … …  
    126127#if PLATFORM(COCOA) && !USE(CFURLCONNECTION)
    127128    WEBCORE_EXPORT NSURLConnection *connection() const;
    128     id makeDelegate(bool);
     129    id makeDelegate(bool, WTF::MessageQueue<WTF::Function<void()>>*);
    129130    id delegate();
    130131    void releaseDelegate();
    … …  
    238239    ResourceHandle(NetworkingContext*, const ResourceRequest&, ResourceHandleClient*, bool defersLoading, bool shouldContentSniff);
    239240
    240     bool usesAsyncCallbacks() const;
    241 
    242241private:
    243242    enum FailureType {
    … …  
    268267
    269268#if USE(CFURLCONNECTION)
    270     void createCFURLConnection(bool shouldUseCredentialStorage, bool shouldContentSniff, SchedulingBehavior, CFDictionaryRef clientProperties);
     269    void createCFURLConnection(bool shouldUseCredentialStorage, bool shouldContentSniff, WTF::MessageQueue<WTF::Function<void()>>*, CFDictionaryRef clientProperties);
    271270#endif
    272271

  • trunk/Source/WebCore/platform/network/ResourceHandleClient.cpp

    r223728 r224267  
    3636
    3737ResourceHandleClient::~ResourceHandleClient() = default;
    38    
    39 ResourceRequest ResourceHandleClient::willSendRequest(ResourceHandle*, ResourceRequest&& request, ResourceResponse&&)
    40 {
    41     return WTFMove(request);
    42 }
    43 
    44 void ResourceHandleClient::willSendRequestAsync(ResourceHandle* handle, ResourceRequest&& request, ResourceResponse&& /*redirectResponse*/)
    45 {
    46     handle->continueWillSendRequest(WTFMove(request));
    47 }
    48 
    49 void ResourceHandleClient::didReceiveResponseAsync(ResourceHandle* handle, ResourceResponse&&)
    50 {
    51     handle->continueDidReceiveResponse();
    52 }
    53 
    54 #if USE(PROTECTION_SPACE_AUTH_CALLBACK)
    55 void ResourceHandleClient::canAuthenticateAgainstProtectionSpaceAsync(ResourceHandle* handle, const ProtectionSpace&)
    56 {
    57     handle->continueCanAuthenticateAgainstProtectionSpace(false);
    58 }
    59 #endif
    6038
    6139#if USE(CFURLCONNECTION)

  • trunk/Source/WebCore/platform/network/ResourceHandleClient.h

    r223408 r224267  
    6464    WEBCORE_EXPORT virtual ~ResourceHandleClient();
    6565
    66     WEBCORE_EXPORT virtual ResourceRequest willSendRequest(ResourceHandle*, ResourceRequest&&, ResourceResponse&&);
    6766    virtual void didSendData(ResourceHandle*, unsigned long long /*bytesSent*/, unsigned long long /*totalBytesToBeSent*/) { }
    6867
    69     virtual void didReceiveResponse(ResourceHandle*, ResourceResponse&&) { }
    70    
    7168    virtual void didReceiveData(ResourceHandle*, const char*, unsigned, int /*encodedDataLength*/) { }
    7269    WEBCORE_EXPORT virtual void didReceiveBuffer(ResourceHandle*, Ref<SharedBuffer>&&, int encodedDataLength);
    … …  
    7774    virtual void cannotShowURL(ResourceHandle*) { }
    7875
    79     virtual bool usesAsyncCallbacks() { return false; }
    80 
    8176    virtual bool loadingSynchronousXHR() { return false; }
    8277
    8378    // Client will pass an updated request using ResourceHandle::continueWillSendRequest() when ready.
    84     WEBCORE_EXPORT virtual void willSendRequestAsync(ResourceHandle*, ResourceRequest&&, ResourceResponse&&);
     79    WEBCORE_EXPORT virtual void willSendRequestAsync(ResourceHandle*, ResourceRequest&&, ResourceResponse&&) = 0;
    8580
    8681    // Client will call ResourceHandle::continueDidReceiveResponse() when ready.
    87     WEBCORE_EXPORT virtual void didReceiveResponseAsync(ResourceHandle*, ResourceResponse&&);
     82    WEBCORE_EXPORT virtual void didReceiveResponseAsync(ResourceHandle*, ResourceResponse&&) = 0;
    8883
    8984#if USE(PROTECTION_SPACE_AUTH_CALLBACK)
    9085    // Client will pass an updated request using ResourceHandle::continueCanAuthenticateAgainstProtectionSpace() when ready.
    91     WEBCORE_EXPORT virtual void canAuthenticateAgainstProtectionSpaceAsync(ResourceHandle*, const ProtectionSpace&);
     86    WEBCORE_EXPORT virtual void canAuthenticateAgainstProtectionSpaceAsync(ResourceHandle*, const ProtectionSpace&) = 0;
    9287#endif
    9388    // Client will pass an updated request using ResourceHandle::continueWillCacheResponse() when ready.
    … …  
    10499    virtual bool shouldUseCredentialStorage(ResourceHandle*) { return false; }
    105100    virtual void didReceiveAuthenticationChallenge(ResourceHandle*, const AuthenticationChallenge&) { }
    106 #if USE(PROTECTION_SPACE_AUTH_CALLBACK)
    107     virtual bool canAuthenticateAgainstProtectionSpace(ResourceHandle*, const ProtectionSpace&) { return false; }
    108 #endif
    109101    virtual void receivedCancellation(ResourceHandle*, const AuthenticationChallenge&) { }
    110102

  • trunk/Source/WebCore/platform/network/ResourceHandleInternal.h

    r223408 r224267  
    8181        , m_defersLoading(defersLoading)
    8282        , m_shouldContentSniff(shouldContentSniff)
    83         , m_usesAsyncCallbacks(client && client->usesAsyncCallbacks())
    8483#if USE(CFURLCONNECTION)
    8584        , m_currentRequest(request)
    … …  
    116115    bool m_defersLoading;
    117116    bool m_shouldContentSniff;
    118     bool m_usesAsyncCallbacks;
    119117#if USE(CFURLCONNECTION)
    120118    RetainPtr<CFURLConnectionRef> m_connection;

  • trunk/Source/WebCore/platform/network/SynchronousLoaderClient.cpp

    r223728 r224267  
    3535SynchronousLoaderClient::~SynchronousLoaderClient() = default;
    3636
    37 ResourceRequest SynchronousLoaderClient::willSendRequest(ResourceHandle* handle, ResourceRequest&& request, ResourceResponse&&)
     37void SynchronousLoaderClient::willSendRequestAsync(ResourceHandle* handle, ResourceRequest&& request, ResourceResponse&&)
    3838{
    3939    // FIXME: This needs to be fixed to follow the redirect correctly even for cross-domain requests.
    40     if (protocolHostAndPortAreEqual(handle->firstRequest().url(), request.url()))
    41         return WTFMove(request);
     40    if (protocolHostAndPortAreEqual(handle->firstRequest().url(), request.url())) {
     41        handle->continueWillSendRequest(WTFMove(request));
     42        return;
     43    }
    4244
    4345    ASSERT(m_error.isNull());
    4446    m_error = platformBadResponseError();
    45     m_isDone = true;
    46     return { };
     47    handle->continueWillSendRequest({ });
    4748}
    4849
    … …  
    5455
    5556#if USE(PROTECTION_SPACE_AUTH_CALLBACK)
    56 bool SynchronousLoaderClient::canAuthenticateAgainstProtectionSpace(ResourceHandle*, const ProtectionSpace&)
     57void SynchronousLoaderClient::canAuthenticateAgainstProtectionSpaceAsync(ResourceHandle* handle, const ProtectionSpace&)
    5758{
    5859    // FIXME: We should ask FrameLoaderClient. <http://webkit.org/b/65196>
    59     return true;
     60    handle->continueCanAuthenticateAgainstProtectionSpace(true);
    6061}
    6162#endif
    6263
    63 void SynchronousLoaderClient::didReceiveResponse(ResourceHandle*, ResourceResponse&& response)
     64void SynchronousLoaderClient::didReceiveResponseAsync(ResourceHandle* handle, ResourceResponse&& response)
    6465{
    6566    m_response = WTFMove(response);
     67    handle->continueDidReceiveResponse();
    6668}
    6769
    … …  
    7375void SynchronousLoaderClient::didFinishLoading(ResourceHandle*)
    7476{
    75     m_isDone = true;
     77    m_messageQueue.kill();
    7678}
    7779
    … …  
    8183
    8284    m_error = error;
    83     m_isDone = true;
     85   
     86    m_messageQueue.kill();
    8487}
    8588

  • trunk/Source/WebCore/platform/network/SynchronousLoaderClient.h

    r223408 r224267  
    2424 */
    2525
    26 #ifndef SynchronousLoaderClient_h
    27 #define SynchronousLoaderClient_h
     26#pragma once
    2827
    2928#include "ResourceError.h"
    3029#include "ResourceHandleClient.h"
    3130#include "ResourceResponse.h"
     31#include <wtf/Function.h>
     32#include <wtf/MessageQueue.h>
    3233
    3334namespace WebCore {
    … …  
    4142    Vector<char>& mutableData() { return m_data; }
    4243    const ResourceError& error() const { return m_error; }
    43     bool isDone() { return m_isDone; }
     44    MessageQueue<Function<void()>>& messageQueue() { return m_messageQueue; }
    4445
    4546    WEBCORE_EXPORT static ResourceError platformBadResponseError();
    4647
    4748private:
    48     ResourceRequest willSendRequest(ResourceHandle*, ResourceRequest&&, ResourceResponse&&) override;
     49    void willSendRequestAsync(ResourceHandle*, ResourceRequest&&, ResourceResponse&&) override;
    4950    bool shouldUseCredentialStorage(ResourceHandle*) override;
    5051    void didReceiveAuthenticationChallenge(ResourceHandle*, const AuthenticationChallenge&) override;
    51     void didReceiveResponse(ResourceHandle*, ResourceResponse&&) override;
     52    void didReceiveResponseAsync(ResourceHandle*, ResourceResponse&&) override;
    5253    void didReceiveData(ResourceHandle*, const char*, unsigned, int /*encodedDataLength*/) override;
    5354    void didFinishLoading(ResourceHandle*) override;
    5455    void didFail(ResourceHandle*, const ResourceError&) override;
    5556#if USE(PROTECTION_SPACE_AUTH_CALLBACK)
    56     bool canAuthenticateAgainstProtectionSpace(ResourceHandle*, const ProtectionSpace&) override;
     57    void canAuthenticateAgainstProtectionSpaceAsync(ResourceHandle*, const ProtectionSpace&) override;
    5758#endif
    5859
    … …  
    6162    Vector<char> m_data;
    6263    ResourceError m_error;
    63     bool m_isDone { false };
     64    MessageQueue<Function<void()>> m_messageQueue;
    6465};
    6566}
    66 
    67 #endif // SynchronousLoaderClient_h

  • trunk/Source/WebCore/platform/network/cf/CookieJarCFNet.cpp

    r223408 r224267  
    6060};
    6161
     62#if COMPILER(CLANG)
     63#pragma clang diagnostic push
     64#pragma clang diagnostic ignored "-Wdeprecated-declarations"
     65#endif
    6266DECLARE_CF_TYPE_TRAIT(CFHTTPCookie);
     67#if COMPILER(CLANG)
     68#pragma clang diagnostic pop
     69#endif
    6370
    6471#undef DECLARE_CF_TYPE_TRAIT

  • trunk/Source/WebCore/platform/network/cf/FormDataStreamCFNet.cpp

    r223408 r224267  
    304304
    305305    if (kCFCompareEqualTo == CFStringCompare(propertyName, formDataPointerPropertyName, 0)) {
    306         long formDataAsNumber = static_cast<long>(reinterpret_cast<intptr_t>(form->formData.get()));
    307         return CFNumberCreate(0, kCFNumberLongType, &formDataAsNumber);
     306        long long formDataAsNumber = static_cast<long long>(reinterpret_cast<intptr_t>(form->formData.get()));
     307        return CFNumberCreate(0, kCFNumberLongLongType, &formDataAsNumber);
    308308    }
    309309

  • trunk/Source/WebCore/platform/network/cf/ResourceHandleCFNet.cpp

    r223408 r224267  
    4040#include "NetworkingContext.h"
    4141#include "ResourceError.h"
     42#include "ResourceHandleCFURLConnectionDelegateWithOperationQueue.h"
    4243#include "ResourceHandleClient.h"
    4344#include "ResourceResponse.h"
    4445#include "SharedBuffer.h"
    4546#include "SynchronousLoaderClient.h"
    46 #include "SynchronousResourceHandleCFURLConnectionDelegate.h"
    4747#include <CFNetwork/CFNetwork.h>
    4848#include <pal/spi/cf/CFNetworkSPI.h>
    … …  
    127127}
    128128
    129 void ResourceHandle::createCFURLConnection(bool shouldUseCredentialStorage, bool shouldContentSniff, SchedulingBehavior schedulingBehavior, CFDictionaryRef clientProperties)
     129void ResourceHandle::createCFURLConnection(bool shouldUseCredentialStorage, bool shouldContentSniff, MessageQueue<Function<void()>>* messageQueue, CFDictionaryRef clientProperties)
    130130{
    131131    if ((!d->m_user.isEmpty() || !d->m_pass.isEmpty()) && !firstRequest().url().protocolIsInHTTPFamily()) {
    … …  
    204204    }
    205205
    206     if (schedulingBehavior == SchedulingBehavior::Synchronous) {
    207         // Synchronous requests should not be subject to regular connection count limit to avoid deadlocks.
    208         // If we are using all available connections for async requests, and make a sync request, then prior
    209         // requests may get stuck waiting for delegate calls while we are in nested run loop, and the sync
    210         // request won't start because there are no available connections.
    211         // Connections are grouped by their socket stream properties, with each group having a separate count.
    212         CFDictionarySetValue(streamProperties, CFSTR("_WebKitSynchronousRequest"), kCFBooleanTrue);
    213     }
    214 
    215206#if PLATFORM(COCOA)
    216207    RetainPtr<CFDataRef> sourceApplicationAuditData = d->m_context->sourceApplicationAuditData();
    … …  
    238229    CFRelease(streamProperties);
    239230
    240 #if PLATFORM(COCOA)
    241     if (d->m_usesAsyncCallbacks)
    242         d->m_connectionDelegate = adoptRef(new ResourceHandleCFURLConnectionDelegateWithOperationQueue(this));
    243     else
    244         d->m_connectionDelegate = adoptRef(new SynchronousResourceHandleCFURLConnectionDelegate(this));
    245 #else
    246     d->m_connectionDelegate = adoptRef(new SynchronousResourceHandleCFURLConnectionDelegate(this));
    247 #endif
     231    d->m_connectionDelegate = adoptRef(new ResourceHandleCFURLConnectionDelegateWithOperationQueue(this, messageQueue));
    248232    d->m_connectionDelegate->setupRequest(request.get());
    249233
    … …  
    276260#endif
    277261
    278     SchedulingBehavior schedulingBehavior = client()->loadingSynchronousXHR() ? SchedulingBehavior::Synchronous : SchedulingBehavior::Asynchronous;
    279 
    280     createCFURLConnection(shouldUseCredentialStorage, d->m_shouldContentSniff, schedulingBehavior, client()->connectionProperties(this).get());
     262    createCFURLConnection(shouldUseCredentialStorage, d->m_shouldContentSniff, nullptr, client()->connectionProperties(this).get());
     263    ref();
    281264
    282265    d->m_connectionDelegate->setupConnectionScheduling(d->m_connection.get());
    … …  
    326309
    327310    Ref<ResourceHandle> protectedThis(*this);
    328     if (d->m_usesAsyncCallbacks) {
    329         client()->willSendRequestAsync(this, WTFMove(request), WTFMove(redirectResponse));
    330         return { };
    331     }
    332    
    333     auto newRequest = client()->willSendRequest(this, WTFMove(request), WTFMove(redirectResponse));
    334 
    335     // Client call may not preserve the session, especially if the request is sent over IPC.
    336     if (!newRequest.isNull()) {
    337         newRequest.setStorageSession(d->m_storageSession.get());
    338 
    339         d->m_currentRequest = newRequest;
    340     }
    341     return newRequest;
     311    client()->willSendRequestAsync(this, WTFMove(request), WTFMove(redirectResponse));
     312    return { };
    342313}
    343314
    … …  
    345316{
    346317    LOG(Network, "CFNet - shouldUseCredentialStorage()");
    347     if (ResourceHandleClient* client = this->client()) {
    348         ASSERT(!d->m_usesAsyncCallbacks);
     318    if (ResourceHandleClient* client = this->client())
    349319        return client->shouldUseCredentialStorage(this);
    350     }
    351320    return false;
    352321}
    … …  
    444413bool ResourceHandle::canAuthenticateAgainstProtectionSpace(const ProtectionSpace& protectionSpace)
    445414{
    446     ResourceHandleClient* client = this->client();
    447     if (d->m_usesAsyncCallbacks) {
    448         if (client)
    449             client->canAuthenticateAgainstProtectionSpaceAsync(this, protectionSpace);
    450         else
    451             continueCanAuthenticateAgainstProtectionSpace(false);
    452         return false; // Ignored by caller.
    453     }
    454 
    455     return client && client->canAuthenticateAgainstProtectionSpace(this, protectionSpace);
     415    if (auto* client = this->client())
     416        client->canAuthenticateAgainstProtectionSpaceAsync(this, protectionSpace);
     417    else
     418        continueCanAuthenticateAgainstProtectionSpace(false);
     419    return false; // Ignored by caller.
    456420}
    457421#endif
    … …  
    575539}
    576540
     541static void emptyPerform(void*)
     542{
     543}
     544
    577545void ResourceHandle::platformLoadResourceSynchronously(NetworkingContext* context, const ResourceRequest& request, StoredCredentialsPolicy storedCredentialsPolicy, ResourceError& error, ResourceResponse& response, Vector<char>& data)
    578546{
    … …  
    596564    }
    597565
    598     handle->createCFURLConnection(storedCredentialsPolicy == StoredCredentialsPolicy::Use, ResourceHandle::shouldContentSniffURL(request.url()),
    599         SchedulingBehavior::Synchronous, handle->client()->connectionProperties(handle.get()).get());
    600 
    601     CFURLConnectionScheduleWithRunLoop(handle->connection(), CFRunLoopGetCurrent(), synchronousLoadRunLoopMode());
    602     CFURLConnectionScheduleDownloadWithRunLoop(handle->connection(), CFRunLoopGetCurrent(), synchronousLoadRunLoopMode());
     566    handle->ref();
     567    handle->createCFURLConnection(storedCredentialsPolicy == StoredCredentialsPolicy::Use, ResourceHandle::shouldContentSniffURL(request.url()), &client.messageQueue(), handle->client()->connectionProperties(handle.get()).get());
     568
     569    static CFRunLoopRef runLoop = nullptr;
     570    if (!runLoop) {
     571        BinarySemaphore sem;
     572        Thread::create("CFNetwork Loader", [&] {
     573            runLoop = CFRunLoopGetCurrent();
     574
     575            // Must add a source to the run loop to prevent CFRunLoopRun() from exiting.
     576            CFRunLoopSourceContext ctxt = { 0, (void*)1 /*must be non-null*/, 0, 0, 0, 0, 0, 0, 0, emptyPerform };
     577            CFRunLoopSourceRef bogusSource = CFRunLoopSourceCreate(0, 0, &ctxt);
     578            CFRunLoopAddSource(runLoop, bogusSource, kCFRunLoopDefaultMode);
     579            sem.signal();
     580
     581            while (true)
     582                CFRunLoopRunInMode(kCFRunLoopDefaultMode, 1E30, true);
     583        });
     584        sem.wait(TimeWithDynamicClockType(WallTime::infinity()));
     585    }
     586    CFURLConnectionScheduleWithRunLoop(handle->connection(), runLoop, kCFRunLoopDefaultMode);
     587    CFURLConnectionScheduleDownloadWithRunLoop(handle->connection(), runLoop, kCFRunLoopDefaultMode);
    603588    CFURLConnectionStart(handle->connection());
    604589
    605     while (!client.isDone())
    606         CFRunLoopRunInMode(synchronousLoadRunLoopMode(), UINT_MAX, true);
     590    do {
     591        if (auto task = client.messageQueue().waitForMessage())
     592            (*task)();
     593    } while (!client.messageQueue().killed());
    607594
    608595    error = client.error();
    609596
    610     CFURLConnectionCancel(handle->connection());
     597    if (handle->connection())
     598        CFURLConnectionCancel(handle->connection());
    611599
    612600    if (error.isNull())

  • trunk/Source/WebCore/platform/network/cf/ResourceHandleCFURLConnectionDelegateWithOperationQueue.cpp

    r223408 r224267  
    3232#include "AuthenticationChallenge.h"
    3333#include "Logging.h"
     34#include "MIMETypeRegistry.h"
    3435#include "ResourceHandle.h"
    3536#include "ResourceHandleClient.h"
    3637#include "ResourceResponse.h"
    3738#include "SharedBuffer.h"
     39#if !PLATFORM(WIN)
    3840#include "WebCoreURLResponse.h"
     41#endif
    3942#include <pal/spi/cf/CFNetworkSPI.h>
    4043#include <wtf/MainThread.h>
     44#include <wtf/Threading.h>
    4145#include <wtf/text/CString.h>
    4246#include <wtf/text/WTFString.h>
    … …  
    4448namespace WebCore {
    4549
    46 ResourceHandleCFURLConnectionDelegateWithOperationQueue::ResourceHandleCFURLConnectionDelegateWithOperationQueue(ResourceHandle* handle)
     50ResourceHandleCFURLConnectionDelegateWithOperationQueue::ResourceHandleCFURLConnectionDelegateWithOperationQueue(ResourceHandle* handle, MessageQueue<Function<void()>>* messageQueue)
    4751    : ResourceHandleCFURLConnectionDelegate(handle)
    48     , m_queue(dispatch_queue_create("com.apple.WebCore/CFNetwork", DISPATCH_QUEUE_SERIAL))
    49     , m_semaphore(dispatch_semaphore_create(0))
    50 {
    51     dispatch_queue_t backgroundQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
    52     dispatch_set_target_queue(m_queue, backgroundQueue);
     52    , m_messageQueue(messageQueue)
     53{
    5354}
    5455
    5556ResourceHandleCFURLConnectionDelegateWithOperationQueue::~ResourceHandleCFURLConnectionDelegateWithOperationQueue()
    5657{
    57     dispatch_release(m_semaphore);
    58     dispatch_release(m_queue);
    5958}
    6059
    … …  
    6968    m_requestResult = nullptr;
    7069    m_cachedResponseResult = nullptr;
    71     m_boolResult = false;
    72     dispatch_semaphore_signal(m_semaphore);
     70    m_semaphore.signal();
    7371}
    7472
    … …  
    8482}
    8583
     84#if PLATFORM(WIN)
     85LRESULT CALLBACK hookToRemoveCFNetworkMessage(int code, WPARAM wParam, LPARAM lParam)
     86{
     87    MSG* msg = reinterpret_cast<MSG*>(lParam);
     88    // This message which CFNetwork sends to itself, will block the main thread, remove it.
     89    if (msg->message == WM_USER + 0xcf)
     90        msg->message = WM_NULL;
     91    return CallNextHookEx(nullptr, code, wParam, lParam);
     92}
     93
     94static void installHookToRemoveCFNetworkMessageBlockingMainThread()
     95{
     96    static HHOOK hook = nullptr;
     97    if (!hook) {
     98        DWORD threadID = ::GetCurrentThreadId();
     99        hook = ::SetWindowsHookExW(WH_GETMESSAGE, hookToRemoveCFNetworkMessage, 0, threadID);
     100    }
     101}
     102#endif
     103
     104static void emptyPerform(void*)
     105{
     106}
     107
     108static CFRunLoopRef getRunLoop()
     109{
     110    static CFRunLoopRef runLoop = nullptr;
     111
     112    if (!runLoop) {
     113        BinarySemaphore sem;
     114        Thread::create("CFNetwork Loader", [&] {
     115            runLoop = CFRunLoopGetCurrent();
     116
     117            // Must add a source to the run loop to prevent CFRunLoopRun() from exiting.
     118            CFRunLoopSourceContext ctxt = { 0, (void*)1 /*must be non-null*/, 0, 0, 0, 0, 0, 0, 0, emptyPerform };
     119            CFRunLoopSourceRef bogusSource = CFRunLoopSourceCreate(0, 0, &ctxt);
     120            CFRunLoopAddSource(runLoop, bogusSource, kCFRunLoopDefaultMode);
     121            sem.signal();
     122
     123            while (true)
     124                CFRunLoopRunInMode(kCFRunLoopDefaultMode, 1E30, true);
     125        });
     126        sem.wait(TimeWithDynamicClockType(WallTime::infinity()));
     127    }
     128
     129    return runLoop;
     130}
     131
    86132void ResourceHandleCFURLConnectionDelegateWithOperationQueue::setupConnectionScheduling(CFURLConnectionRef connection)
    87133{
    88     CFURLConnectionSetDelegateDispatchQueue(connection, m_queue);
     134#if PLATFORM(WIN)
     135    installHookToRemoveCFNetworkMessageBlockingMainThread();
     136#endif
     137    CFRunLoopRef runLoop = getRunLoop();
     138    CFURLConnectionScheduleWithRunLoop(connection, runLoop, kCFRunLoopDefaultMode);
     139    CFURLConnectionScheduleDownloadWithRunLoop(connection, runLoop, kCFRunLoopDefaultMode);
    89140}
    90141
    … …  
    102153    ASSERT(!isMainThread());
    103154   
    104     struct ProtectedParameters {
    105         Ref<ResourceHandleCFURLConnectionDelegateWithOperationQueue> protectedThis;
    106         RetainPtr<CFURLRequestRef> cfRequest;
    107         RetainPtr<CFURLResponseRef> originalRedirectResponse;
    108     };
    109    
    110     auto work = [] (void* context) {
    111         auto& parameters = *reinterpret_cast<ProtectedParameters*>(context);
    112         auto& protectedThis = parameters.protectedThis;
    113         auto& handle = protectedThis->m_handle;
    114         auto& cfRequest = parameters.cfRequest;
     155    auto work = [protectedThis = makeRef(*this), cfRequest = RetainPtr<CFURLRequestRef>(cfRequest), originalRedirectResponse = RetainPtr<CFURLResponseRef>(originalRedirectResponse)] () {
     156        auto& handle = protectedThis->m_handle;
    115157       
    116158        if (!protectedThis->hasHandle()) {
    … …  
    121163        LOG(Network, "CFNet - ResourceHandleCFURLConnectionDelegateWithOperationQueue::willSendRequest(handle=%p) (%s)", handle, handle->firstRequest().url().string().utf8().data());
    122164
    123         RetainPtr<CFURLResponseRef> redirectResponse = protectedThis->synthesizeRedirectResponseIfNecessary(cfRequest.get(), parameters.originalRedirectResponse.get());
     165        RetainPtr<CFURLResponseRef> redirectResponse = protectedThis->synthesizeRedirectResponseIfNecessary(cfRequest.get(), originalRedirectResponse.get());
    124166        ASSERT(redirectResponse);
    125167
    … …  
    128170    };
    129171   
    130     ProtectedParameters parameters { makeRef(*this), cfRequest, originalRedirectResponse };
    131     dispatch_async_f(dispatch_get_main_queue(), &parameters, work);
    132     dispatch_semaphore_wait(m_semaphore, DISPATCH_TIME_FOREVER);
     172    if (m_messageQueue)
     173        m_messageQueue->append(std::make_unique<Function<void()>>(WTFMove(work)));
     174    else
     175        callOnMainThread(WTFMove(work));
     176    m_semaphore.wait(TimeWithDynamicClockType(WallTime::infinity()));
    133177
    134178    return m_requestResult.leakRef();
    … …  
    137181void ResourceHandleCFURLConnectionDelegateWithOperationQueue::didReceiveResponse(CFURLConnectionRef connection, CFURLResponseRef cfResponse)
    138182{
    139     struct ProtectedParameters {
    140         Ref<ResourceHandleCFURLConnectionDelegateWithOperationQueue> protectedThis;
    141         RetainPtr<CFURLConnectionRef> connection;
    142         RetainPtr<CFURLResponseRef> cfResponse;
    143     };
    144    
    145     auto work = [] (void* context) {
    146         auto& parameters = *reinterpret_cast<ProtectedParameters*>(context);
    147         auto& protectedThis = parameters.protectedThis;
    148         auto& handle = protectedThis->m_handle;
    149         auto& cfResponse = parameters.cfResponse;
    150        
    151         if (!protectedThis->hasHandle() || !handle->client()) {
     183    auto work = [protectedThis = makeRef(*this), cfResponse = RetainPtr<CFURLResponseRef>(cfResponse), connection = RetainPtr<CFURLConnectionRef>(connection)] () {
     184        auto& handle = protectedThis->m_handle;
     185       
     186        if (!protectedThis->hasHandle() || !handle->client() || !handle->connection()) {
    152187            protectedThis->continueDidReceiveResponse();
    153188            return;
    … …  
    162197        if (statusCode != 304) {
    163198            bool isMainResourceLoad = handle->firstRequest().requester() == ResourceRequest::Requester::Main;
     199#if !PLATFORM(WIN)
    164200            adjustMIMETypeIfNecessary(cfResponse.get(), isMainResourceLoad);
     201#endif
    165202        }
    166203
    … …  
    171208
    172209        ResourceResponse resourceResponse(cfResponse.get());
    173         ResourceHandle::getConnectionTimingData(parameters.connection.get(), resourceResponse.deprecatedNetworkLoadMetrics());
     210        resourceResponse.setSource(ResourceResponse::Source::Network);
     211#if !PLATFORM(WIN)
     212        ResourceHandle::getConnectionTimingData(connection.get(), resourceResponse.deprecatedNetworkLoadMetrics());
     213#endif
    174214
    175215        handle->didReceiveResponse(WTFMove(resourceResponse));
    176216    };
    177217
    178     ProtectedParameters parameters { makeRef(*this), connection, cfResponse };
    179     dispatch_async_f(dispatch_get_main_queue(), &parameters, work);
    180     dispatch_semaphore_wait(m_semaphore, DISPATCH_TIME_FOREVER);
     218    if (m_messageQueue)
     219        m_messageQueue->append(std::make_unique<Function<void()>>(WTFMove(work)));
     220    else
     221        callOnMainThread(WTFMove(work));
     222    m_semaphore.wait(TimeWithDynamicClockType(WallTime::infinity()));
    181223}
    182224
    183225void ResourceHandleCFURLConnectionDelegateWithOperationQueue::didReceiveData(CFDataRef data, CFIndex originalLength)
    184226{
    185     callOnMainThread([protectedThis = makeRef(*this), data = RetainPtr<CFDataRef>(data), originalLength = originalLength] () mutable {
    186         auto& handle = protectedThis->m_handle;
    187         if (!protectedThis->hasHandle() || !handle->client())
     227    auto work = [protectedThis = makeRef(*this), data = RetainPtr<CFDataRef>(data), originalLength = originalLength] () mutable {
     228        auto& handle = protectedThis->m_handle;
     229        if (!protectedThis->hasHandle() || !handle->client() || !handle->connection())
    188230            return;
    189231       
    … …  
    191233
    192234        handle->client()->didReceiveBuffer(handle, SharedBuffer::create(data.get()), originalLength);
    193     });
     235    };
     236   
     237    if (m_messageQueue)
     238        m_messageQueue->append(std::make_unique<Function<void()>>(WTFMove(work)));
     239    else
     240        callOnMainThread(WTFMove(work));
    194241}
    195242
    196243void ResourceHandleCFURLConnectionDelegateWithOperationQueue::didFinishLoading()
    197244{
    198     callOnMainThread([protectedThis = makeRef(*this)] () mutable {
    199         auto& handle = protectedThis->m_handle;
    200         if (!protectedThis->hasHandle() || !handle->client())
    201             return;
     245    auto work = [protectedThis = makeRef(*this)] () mutable {
     246        auto& handle = protectedThis->m_handle;
     247        if (!protectedThis->hasHandle() || !handle->client() || !handle->connection()) {
     248            protectedThis->m_handle->deref();
     249            return;
     250        }
    202251
    203252        LOG(Network, "CFNet - ResourceHandleCFURLConnectionDelegateWithOperationQueue::didFinishLoading(handle=%p) (%s)", handle, handle->firstRequest().url().string().utf8().data());
    204253
    205254        handle->client()->didFinishLoading(handle);
    206     });
     255        if (protectedThis->m_messageQueue) {
     256            protectedThis->m_messageQueue->kill();
     257            protectedThis->m_messageQueue = nullptr;
     258        }
     259        protectedThis->m_handle->deref();
     260    };
     261   
     262    if (m_messageQueue)
     263        m_messageQueue->append(std::make_unique<Function<void()>>(WTFMove(work)));
     264    else
     265        callOnMainThread(WTFMove(work));
    207266}
    208267
    209268void ResourceHandleCFURLConnectionDelegateWithOperationQueue::didFail(CFErrorRef error)
    210269{
    211     callOnMainThread([protectedThis = makeRef(*this), error = RetainPtr<CFErrorRef>(error)] () mutable {
    212         auto& handle = protectedThis->m_handle;
    213         if (!protectedThis->hasHandle() || !handle->client())
    214             return;
     270    auto work = [protectedThis = makeRef(*this), error = RetainPtr<CFErrorRef>(error)] () mutable {
     271        auto& handle = protectedThis->m_handle;
     272        if (!protectedThis->hasHandle() || !handle->client() || !handle->connection()) {
     273            protectedThis->m_handle->deref();
     274            return;
     275        }
    215276       
    216277        LOG(Network, "CFNet - ResourceHandleCFURLConnectionDelegateWithOperationQueue::didFail(handle=%p) (%s)", handle, handle->firstRequest().url().string().utf8().data());
    217278
    218279        handle->client()->didFail(handle, ResourceError(error.get()));
    219     });
     280        if (protectedThis->m_messageQueue) {
     281            protectedThis->m_messageQueue->kill();
     282            protectedThis->m_messageQueue = nullptr;
     283        }
     284        protectedThis->m_handle->deref();
     285    };
     286
     287    if (m_messageQueue)
     288        m_messageQueue->append(std::make_unique<Function<void()>>(WTFMove(work)));
     289    else
     290        callOnMainThread(WTFMove(work));
    220291}
    221292
    222293CFCachedURLResponseRef ResourceHandleCFURLConnectionDelegateWithOperationQueue::willCacheResponse(CFCachedURLResponseRef cachedResponse)
    223294{
    224     struct ProtectedParameters {
    225         Ref<ResourceHandleCFURLConnectionDelegateWithOperationQueue> protectedThis;
    226         RetainPtr<CFCachedURLResponseRef> cachedResponse;
    227     };
    228    
    229     auto work = [] (void* context) {
    230         auto& parameters = *reinterpret_cast<ProtectedParameters*>(context);
    231         auto& protectedThis = parameters.protectedThis;
    232         auto& handle = protectedThis->m_handle;
    233        
    234         if (!protectedThis->hasHandle() || !handle->client()) {
     295#if PLATFORM(WIN)
     296    // Workaround for <rdar://problem/6300990> Caching does not respect Vary HTTP header.
     297    // FIXME: WebCore cache has issues with Vary, too (bug 58797, bug 71509).
     298    CFURLResponseRef wrappedResponse = CFCachedURLResponseGetWrappedResponse(cachedResponse);
     299    if (CFHTTPMessageRef httpResponse = CFURLResponseGetHTTPResponse(wrappedResponse)) {
     300        ASSERT(CFHTTPMessageIsHeaderComplete(httpResponse));
     301        RetainPtr<CFStringRef> varyValue = adoptCF(CFHTTPMessageCopyHeaderFieldValue(httpResponse, CFSTR("Vary")));
     302        if (varyValue)
     303            return nullptr;
     304    }
     305#endif // PLATFORM(WIN)
     306
     307    auto work = [protectedThis = makeRef(*this), cachedResponse = RetainPtr<CFCachedURLResponseRef>(cachedResponse)] () {
     308        auto& handle = protectedThis->m_handle;
     309       
     310        if (!protectedThis->hasHandle() || !handle->client() || !handle->connection()) {
    235311            protectedThis->continueWillCacheResponse(nullptr);
    236312            return;
    … …  
    239315        LOG(Network, "CFNet - ResourceHandleCFURLConnectionDelegateWithOperationQueue::willCacheResponse(handle=%p) (%s)", handle, handle->firstRequest().url().string().utf8().data());
    240316
    241         handle->client()->willCacheResponseAsync(handle, parameters.cachedResponse.get());
    242     };
    243    
    244     ProtectedParameters parameters { makeRef(*this), cachedResponse };
    245     dispatch_async_f(dispatch_get_main_queue(), &parameters, work);
    246     dispatch_semaphore_wait(m_semaphore, DISPATCH_TIME_FOREVER);
     317        handle->client()->willCacheResponseAsync(handle, cachedResponse.get());
     318    };
     319   
     320    if (m_messageQueue)
     321        m_messageQueue->append(std::make_unique<Function<void()>>(WTFMove(work)));
     322    else
     323        callOnMainThread(WTFMove(work));
     324    m_semaphore.wait(TimeWithDynamicClockType(WallTime::infinity()));
    247325    return m_cachedResponseResult.leakRef();
    248326}
    … …  
    250328void ResourceHandleCFURLConnectionDelegateWithOperationQueue::didReceiveChallenge(CFURLAuthChallengeRef challenge)
    251329{
    252     callOnMainThread([protectedThis = makeRef(*this), challenge = RetainPtr<CFURLAuthChallengeRef>(challenge)] () mutable {
     330    auto work = [protectedThis = makeRef(*this), challenge = RetainPtr<CFURLAuthChallengeRef>(challenge)] () mutable {
    253331        auto& handle = protectedThis->m_handle;
    254332        if (!protectedThis->hasHandle())
    … …  
    258336
    259337        handle->didReceiveAuthenticationChallenge(AuthenticationChallenge(challenge.get(), handle));
    260     });
     338    };
     339
     340    if (m_messageQueue)
     341        m_messageQueue->append(std::make_unique<Function<void()>>(WTFMove(work)));
     342    else
     343        callOnMainThread(WTFMove(work));
    261344}
    262345
    263346void ResourceHandleCFURLConnectionDelegateWithOperationQueue::didSendBodyData(CFIndex totalBytesWritten, CFIndex totalBytesExpectedToWrite)
    264347{
    265     callOnMainThread([protectedThis = makeRef(*this), totalBytesWritten, totalBytesExpectedToWrite] () mutable {
     348    auto work = [protectedThis = makeRef(*this), totalBytesWritten, totalBytesExpectedToWrite] () mutable {
    266349        auto& handle = protectedThis->m_handle;
    267350        if (!protectedThis->hasHandle() || !handle->client() || !handle->connection())
    … …  
    271354
    272355        handle->client()->didSendData(handle, totalBytesWritten, totalBytesExpectedToWrite);
    273     });
     356    };
     357
     358    if (m_messageQueue)
     359        m_messageQueue->append(std::make_unique<Function<void()>>(WTFMove(work)));
     360    else
     361        callOnMainThread(WTFMove(work));
    274362}
    275363
    276364Boolean ResourceHandleCFURLConnectionDelegateWithOperationQueue::shouldUseCredentialStorage()
    277365{
    278     return NO;
     366    return false;
    279367}
    280368
    … …  
    282370Boolean ResourceHandleCFURLConnectionDelegateWithOperationQueue::canRespondToProtectionSpace(CFURLProtectionSpaceRef protectionSpace)
    283371{
    284     struct ProtectedParameters {
    285         Ref<ResourceHandleCFURLConnectionDelegateWithOperationQueue> protectedThis;
    286         RetainPtr<CFURLProtectionSpaceRef> protectionSpace;
    287     };
    288    
    289     auto work = [] (void* context) {
    290         auto& parameters = *reinterpret_cast<ProtectedParameters*>(context);
    291         auto& protectedThis = parameters.protectedThis;
     372    auto work = [protectedThis = makeRef(*this), protectionSpace = RetainPtr<CFURLProtectionSpaceRef>(protectionSpace)] () mutable {
    292373        auto& handle = protectedThis->m_handle;
    293374       
    … …  
    299380        LOG(Network, "CFNet - ResourceHandleCFURLConnectionDelegateWithOperationQueue::canRespondToProtectionSpace(handle=%p) (%s)", handle, handle->firstRequest().url().string().utf8().data());
    300381
    301         ProtectionSpace coreProtectionSpace = ProtectionSpace(parameters.protectionSpace.get());
     382        ProtectionSpace coreProtectionSpace = ProtectionSpace(protectionSpace.get());
    302383#if PLATFORM(IOS)
    303384        if (coreProtectionSpace.authenticationScheme() == ProtectionSpaceAuthenticationSchemeUnknown) {
    … …  
    310391    };
    311392   
    312     ProtectedParameters parameters { makeRef(*this), protectionSpace };
    313     dispatch_async_f(dispatch_get_main_queue(), &parameters, work);
    314     dispatch_semaphore_wait(m_semaphore, DISPATCH_TIME_FOREVER);
     393    if (m_messageQueue)
     394        m_messageQueue->append(std::make_unique<Function<void()>>(WTFMove(work)));
     395    else
     396        callOnMainThread(WTFMove(work));
     397    m_semaphore.wait(TimeWithDynamicClockType(WallTime::infinity()));
    315398    return m_boolResult;
    316399}
     400
     401void ResourceHandleCFURLConnectionDelegateWithOperationQueue::continueCanAuthenticateAgainstProtectionSpace(bool canAuthenticate)
     402{
     403    m_boolResult = canAuthenticate;
     404    m_semaphore.signal();
     405}
    317406#endif // USE(PROTECTION_SPACE_AUTH_CALLBACK)
    318407
    … …  
    320409{
    321410    m_requestResult = request;
    322     dispatch_semaphore_signal(m_semaphore);
     411    m_semaphore.signal();
    323412}
    324413
    325414void ResourceHandleCFURLConnectionDelegateWithOperationQueue::continueDidReceiveResponse()
    326415{
    327     dispatch_semaphore_signal(m_semaphore);
     416    m_semaphore.signal();
    328417}
    329418
    … …  
    331420{
    332421    m_cachedResponseResult = response;
    333     dispatch_semaphore_signal(m_semaphore);
    334 }
    335 
    336 #if USE(PROTECTION_SPACE_AUTH_CALLBACK)
    337 void ResourceHandleCFURLConnectionDelegateWithOperationQueue::continueCanAuthenticateAgainstProtectionSpace(bool canAuthenticate)
    338 {
    339     m_boolResult = canAuthenticate;
    340     dispatch_semaphore_signal(m_semaphore);
    341 }
    342 #endif // USE(PROTECTION_SPACE_AUTH_CALLBACK)
     422    m_semaphore.signal();
     423}
     424
    343425} // namespace WebCore
    344426

  • trunk/Source/WebCore/platform/network/cf/ResourceHandleCFURLConnectionDelegateWithOperationQueue.h

    r223408 r224267  
    3131#include <CFNetwork/CFNetwork.h>
    3232#include <dispatch/queue.h>
    33 #include <dispatch/semaphore.h>
     33#include <wtf/Function.h>
     34#include <wtf/MessageQueue.h>
     35#include <wtf/threads/BinarySemaphore.h>
    3436
    3537namespace WebCore {
    … …  
    3739class ResourceHandleCFURLConnectionDelegateWithOperationQueue final : public ResourceHandleCFURLConnectionDelegate {
    3840public:
    39     ResourceHandleCFURLConnectionDelegateWithOperationQueue(ResourceHandle*);
     41    ResourceHandleCFURLConnectionDelegateWithOperationQueue(ResourceHandle*, MessageQueue<Function<void()>>*);
    4042    virtual ~ResourceHandleCFURLConnectionDelegateWithOperationQueue();
    4143
    … …  
    5658    void didSendBodyData(CFIndex totalBytesWritten, CFIndex totalBytesExpectedToWrite) override;
    5759    Boolean shouldUseCredentialStorage() override;
    58 #if USE(PROTECTION_SPACE_AUTH_CALLBACK)
    59     Boolean canRespondToProtectionSpace(CFURLProtectionSpaceRef) override;
    60 #endif // USE(PROTECTION_SPACE_AUTH_CALLBACK)
    6160
    6261    void continueWillSendRequest(CFURLRequestRef) override;
    … …  
    6463    void continueWillCacheResponse(CFCachedURLResponseRef) override;
    6564#if USE(PROTECTION_SPACE_AUTH_CALLBACK)
     65    Boolean canRespondToProtectionSpace(CFURLProtectionSpaceRef) override;
    6666    void continueCanAuthenticateAgainstProtectionSpace(bool) override;
    67 #endif // USE(PROTECTION_SPACE_AUTH_CALLBACK)
     67#endif
    6868
    69     dispatch_queue_t m_queue;
    70     dispatch_semaphore_t m_semaphore;
     69    BinarySemaphore m_semaphore;
     70    MessageQueue<Function<void()>>* m_messageQueue { nullptr };
    7171
    7272    RetainPtr<CFURLRequestRef> m_requestResult;
    7373    RetainPtr<CFCachedURLResponseRef> m_cachedResponseResult;
    74     bool m_boolResult;
     74    bool m_boolResult { false };
    7575};
    7676

  • trunk/Source/WebCore/platform/network/cf/ResourceRequestCFNet.cpp

    r223408 r224267  
    180180        CString utf8String = partition.utf8();
    181181        RetainPtr<CFStringRef> partitionValue = adoptCF(CFStringCreateWithBytes(0, reinterpret_cast<const UInt8*>(utf8String.data()), utf8String.length(), kCFStringEncodingUTF8, false));
    182         _CFURLRequestSetProtocolProperty(cfRequest, kCFURLCachePartitionKey, partitionValue.get());
     182        _CFURLRequestSetProtocolProperty(cfRequest, _kCFURLCachePartitionKey, partitionValue.get());
    183183    }
    184184#endif
    … …  
    292292
    293293#if ENABLE(CACHE_PARTITIONING)
    294     RetainPtr<CFStringRef> cachePartition = adoptCF(static_cast<CFStringRef>(_CFURLRequestCopyProtocolPropertyForKey(m_cfRequest.get(), kCFURLCachePartitionKey)));
     294    RetainPtr<CFStringRef> cachePartition = adoptCF(static_cast<CFStringRef>(_CFURLRequestCopyProtocolPropertyForKey(m_cfRequest.get(), _kCFURLCachePartitionKey)));
    295295    if (cachePartition)
    296296        m_cachePartition = cachePartition.get();

  • trunk/Source/WebCore/platform/network/curl/MultipartHandle.cpp

    r223408 r224267  
    351351        response.setTextEncodingName(extractCharsetFromMediaType(contentType));
    352352
    353         d->client()->didReceiveResponse(m_resourceHandle, WTFMove(response));
     353        m_resourceHandle->didReceiveResponse(WTFMove(response));
    354354    }
    355355}

  • trunk/Source/WebCore/platform/network/curl/ResourceHandleCurl.cpp

    r223728 r224267  
    275275{
    276276    ASSERT(isMainThread());
    277     ASSERT(!client() || client()->usesAsyncCallbacks());
    278277
    279278    if (d->m_delegate)

  • trunk/Source/WebCore/platform/network/curl/ResourceHandleCurlDelegate.cpp

    r224037 r224267  
    364364
    365365    ResourceResponse responseCopy = response();
    366     if (m_handle->client()->usesAsyncCallbacks())
    367         m_handle->client()->willSendRequestAsync(m_handle, WTFMove(newRequest), WTFMove(responseCopy));
    368     else {
    369         auto request = m_handle->client()->willSendRequest(m_handle, WTFMove(newRequest), WTFMove(responseCopy));
    370         continueAfterWillSendRequest(WTFMove(request));
    371     }
     366    m_handle->client()->willSendRequestAsync(m_handle, WTFMove(newRequest), WTFMove(responseCopy));
    372367}
    373368
    … …  
    445440    if (base64) {
    446441        data = decodeURLEscapeSequences(data);
    447         m_handle->client()->didReceiveResponse(m_handle, WTFMove(response));
     442        m_handle->didReceiveResponse(WTFMove(response));
    448443
    449444        // didReceiveResponse might cause the client to be deleted.
    … …  
    456451        TextEncoding encoding(charset);
    457452        data = decodeURLEscapeSequences(data, encoding);
    458         m_handle->client()->didReceiveResponse(m_handle, WTFMove(response));
     453        m_handle->didReceiveResponse(WTFMove(response));
    459454
    460455        // didReceiveResponse might cause the client to be deleted.

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

    r223408 r224267  
    4444@end
    4545
     46#endif
     47
    4648namespace WebCore {
     49
     50static NSArray *httpCookies(CFHTTPCookieStorageRef cookieStorage)
     51{
     52    if (!cookieStorage)
     53        return [[NSHTTPCookieStorage sharedHTTPCookieStorage] cookies];
     54   
     55    auto cookies = adoptCF(CFHTTPCookieStorageCopyCookies(cookieStorage));
     56    return [NSHTTPCookie _cf2nsCookies:cookies.get()];
     57}
     58
     59static void deleteHTTPCookie(CFHTTPCookieStorageRef cookieStorage, NSHTTPCookie *cookie)
     60{
     61    if (!cookieStorage) {
     62        [[NSHTTPCookieStorage sharedHTTPCookieStorage] deleteCookie:cookie];
     63        return;
     64    }
     65   
     66    CFHTTPCookieStorageDeleteCookie(cookieStorage, [cookie _GetInternalCFHTTPCookie]);
     67}
     68
     69#if !USE(CFURLCONNECTION)
    4770
    4871static NSArray *httpCookiesForURL(CFHTTPCookieStorageRef cookieStorage, NSURL *firstParty, NSURL *url)
    … …  
    181204}
    182205
    183 static NSArray *httpCookies(CFHTTPCookieStorageRef cookieStorage)
    184 {
    185     if (!cookieStorage)
    186         return [[NSHTTPCookieStorage sharedHTTPCookieStorage] cookies];
    187 
    188     auto cookies = adoptCF(CFHTTPCookieStorageCopyCookies(cookieStorage));
    189     return [NSHTTPCookie _cf2nsCookies:cookies.get()];
    190 }
    191 
    192206static void setHTTPCookiesForURL(CFHTTPCookieStorageRef cookieStorage, NSArray *cookies, NSURL *url, NSURL *mainDocumentURL)
    193207{
    … …  
    199213    auto cfCookies = adoptCF([NSHTTPCookie _ns2cfCookies:cookies]);
    200214    CFHTTPCookieStorageSetCookies(cookieStorage, cfCookies.get(), [url _cfurl], [mainDocumentURL _cfurl]);
    201 }
    202 
    203 static void deleteHTTPCookie(CFHTTPCookieStorageRef cookieStorage, NSHTTPCookie *cookie)
    204 {
    205     if (!cookieStorage) {
    206         [[NSHTTPCookieStorage sharedHTTPCookieStorage] deleteCookie:cookie];
    207         return;
    208     }
    209 
    210     CFHTTPCookieStorageDeleteCookie(cookieStorage, [cookie _GetInternalCFHTTPCookie]);
    211215}
    212216
    … …  
    345349}
    346350
    347 }
    348 
    349351#endif // !USE(CFURLCONNECTION)
    350 
    351 namespace WebCore {
    352352
    353353void deleteCookiesForHostnames(const NetworkStorageSession& session, const Vector<String>& hostnames)

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

    r223408 r224267  
    4545#import "SubresourceLoader.h"
    4646#import "SynchronousLoaderClient.h"
    47 #import "WebCoreResourceHandleAsDelegate.h"
    4847#import "WebCoreResourceHandleAsOperationQueueDelegate.h"
    4948#import "WebCoreURLResponse.h"
    … …  
    249248#if !PLATFORM(IOS)
    250249    createNSURLConnection(
    251         ResourceHandle::makeDelegate(shouldUseCredentialStorage),
     250        ResourceHandle::makeDelegate(shouldUseCredentialStorage, nullptr),
    252251        shouldUseCredentialStorage,
    253252        d->m_shouldContentSniff || d->m_context->localFileContentSniffingEnabled(),
    … …  
    255254#else
    256255    createNSURLConnection(
    257         ResourceHandle::makeDelegate(shouldUseCredentialStorage),
     256        ResourceHandle::makeDelegate(shouldUseCredentialStorage, nullptr),
    258257        shouldUseCredentialStorage,
    259258        d->m_shouldContentSniff || d->m_context->localFileContentSniffingEnabled(),
    … …  
    262261#endif
    263262
    264     bool scheduled = false;
    265     if (SchedulePairHashSet* scheduledPairs = d->m_context->scheduledRunLoopPairs()) {
    266         SchedulePairHashSet::iterator end = scheduledPairs->end();
    267         for (SchedulePairHashSet::iterator it = scheduledPairs->begin(); it != end; ++it) {
    268             if (NSRunLoop *runLoop = (*it)->nsRunLoop()) {
    269                 [connection() scheduleInRunLoop:runLoop forMode:(NSString *)(*it)->mode()];
    270                 scheduled = true;
    271             }
    272         }
    273     }
    274 
    275     if (d->m_usesAsyncCallbacks) {
    276         ASSERT(!scheduled);
    277         [connection() setDelegateQueue:operationQueueForAsyncClients()];
    278         scheduled = true;
    279     }
    280 #if PLATFORM(IOS)
    281     else {
    282         [connection() scheduleInRunLoop:WebThreadNSRunLoop() forMode:NSDefaultRunLoopMode];
    283         scheduled = true;
    284     }
    285 #endif
    286 
    287     // Start the connection if we did schedule with at least one runloop.
    288     // We can't start the connection until we have one runloop scheduled.
    289     if (scheduled)
    290         [connection() start];
    291     else
    292         d->m_startWhenScheduled = true;
     263    [connection() setDelegateQueue:operationQueueForAsyncClients()];
     264    [connection() start];
    293265
    294266    LOG(Network, "Handle %p starting connection %p for %@", this, connection(), firstRequest().nsURLRequest(DoNotUpdateHTTPBody));
    … …  
    331303        return;
    332304    [d->m_connection.get() scheduleInRunLoop:runLoop forMode:(NSString *)pair.mode()];
    333     if (d->m_startWhenScheduled) {
    334         [d->m_connection.get() start];
    335         d->m_startWhenScheduled = false;
    336     }
    337305}
    338306
    … …  
    345313#endif
    346314
    347 id ResourceHandle::makeDelegate(bool shouldUseCredentialStorage)
     315id ResourceHandle::makeDelegate(bool shouldUseCredentialStorage, MessageQueue<Function<void()>>* queue)
    348316{
    349317    ASSERT(!d->m_delegate);
    350318
    351319    id <NSURLConnectionDelegate> delegate;
    352     if (d->m_usesAsyncCallbacks) {
    353         if (shouldUseCredentialStorage)
    354             delegate = [[WebCoreResourceHandleAsOperationQueueDelegate alloc] initWithHandle:this];
    355         else
    356             delegate = [[WebCoreResourceHandleWithCredentialStorageAsOperationQueueDelegate alloc] initWithHandle:this];
    357     } else
    358         delegate = [[WebCoreResourceHandleAsDelegate alloc] initWithHandle:this];
     320    if (shouldUseCredentialStorage)
     321        delegate = [[WebCoreResourceHandleAsOperationQueueDelegate alloc] initWithHandle:this messageQueue:queue];
     322    else
     323        delegate = [[WebCoreResourceHandleWithCredentialStorageAsOperationQueueDelegate alloc] initWithHandle:this messageQueue:queue];
    359324
    360325    d->m_delegate = delegate;
    … …  
    367332{
    368333    if (!d->m_delegate)
    369         return makeDelegate(false);
     334        return makeDelegate(false, nullptr);
    370335    return d->m_delegate.get();
    371336}
    … …  
    410375#if !PLATFORM(IOS)
    411376    handle->createNSURLConnection(
    412         handle->makeDelegate(shouldUseCredentialStorage),
     377        handle->makeDelegate(shouldUseCredentialStorage, &client.messageQueue()),
    413378        shouldUseCredentialStorage,
    414379        handle->shouldContentSniff() || context->localFileContentSniffingEnabled(),
    … …  
    416381#else
    417382    handle->createNSURLConnection(
    418         handle->makeDelegate(shouldUseCredentialStorage), // A synchronous request cannot turn into a download, so there is no need to proxy the delegate.
     383        handle->makeDelegate(shouldUseCredentialStorage, &client.messageQueue()), // A synchronous request cannot turn into a download, so there is no need to proxy the delegate.
    419384        shouldUseCredentialStorage,
    420385        handle->shouldContentSniff() || (context && context->localFileContentSniffingEnabled()),
    … …  
    423388#endif
    424389
    425     [handle->connection() scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:(NSString *)synchronousLoadRunLoopMode()];
     390    [handle->connection() setDelegateQueue:operationQueueForAsyncClients()];
    426391    [handle->connection() start];
    427392   
    428     while (!client.isDone())
    429         [[NSRunLoop currentRunLoop] runMode:(NSString *)synchronousLoadRunLoopMode() beforeDate:[NSDate distantFuture]];
     393    do {
     394        if (auto task = client.messageQueue().waitForMessage())
     395            (*task)();
     396    } while (!client.messageQueue().killed());
    430397
    431398    error = client.error();
    … …  
    487454    }
    488455
    489     if (d->m_usesAsyncCallbacks) {
    490         client()->willSendRequestAsync(this, WTFMove(request), WTFMove(redirectResponse));
    491         return { };
    492     }
    493 
    494     Ref<ResourceHandle> protectedThis(*this);
    495     auto newRequest = client()->willSendRequest(this, WTFMove(request), WTFMove(redirectResponse));
    496 
    497     // Client call may not preserve the session, especially if the request is sent over IPC.
    498     if (!newRequest.isNull())
    499         newRequest.setStorageSession(d->m_storageSession.get());
    500     return newRequest;
     456    client()->willSendRequestAsync(this, WTFMove(request), WTFMove(redirectResponse));
     457    return { };
    501458}
    502459
    503460void ResourceHandle::continueWillSendRequest(ResourceRequest&& newRequest)
    504461{
    505     ASSERT(d->m_usesAsyncCallbacks);
    506 
    507462    // Client call may not preserve the session, especially if the request is sent over IPC.
    508463    if (!newRequest.isNull())
    … …  
    513468void ResourceHandle::continueDidReceiveResponse()
    514469{
    515     ASSERT(d->m_usesAsyncCallbacks);
    516 
    517470    [delegate() continueDidReceiveResponse];
    518 }
    519 
    520 bool ResourceHandle::shouldUseCredentialStorage()
    521 {
    522     ASSERT(!d->m_usesAsyncCallbacks);
    523     return client() && client()->shouldUseCredentialStorage(this);
    524471}
    525472
    … …  
    619566bool ResourceHandle::canAuthenticateAgainstProtectionSpace(const ProtectionSpace& protectionSpace)
    620567{
    621     ResourceHandleClient* client = this->client();
    622     if (d->m_usesAsyncCallbacks) {
    623         if (client)
    624             client->canAuthenticateAgainstProtectionSpaceAsync(this, protectionSpace);
    625         else
    626             continueCanAuthenticateAgainstProtectionSpace(false);
    627         return false; // Ignored by caller.
    628     }
    629 
    630     return client && client->canAuthenticateAgainstProtectionSpace(this, protectionSpace);
     568    if (ResourceHandleClient* client = this->client())
     569        client->canAuthenticateAgainstProtectionSpaceAsync(this, protectionSpace);
     570    else
     571        continueCanAuthenticateAgainstProtectionSpace(false);
     572    return false; // Ignored by caller.
    631573}
    632574
    633575void ResourceHandle::continueCanAuthenticateAgainstProtectionSpace(bool result)
    634576{
    635     ASSERT(d->m_usesAsyncCallbacks);
    636 
    637577    [(id)delegate() continueCanAuthenticateAgainstProtectionSpace:result];
    638578}
    … …  
    720660void ResourceHandle::continueWillCacheResponse(NSCachedURLResponse *response)
    721661{
    722     ASSERT(d->m_usesAsyncCallbacks);
    723 
    724662    [(id)delegate() continueWillCacheResponse:response];
    725663}

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

    r223408 r224267  
    2828#if !USE(CFURLCONNECTION)
    2929
    30 #include "WebCoreResourceHandleAsDelegate.h"
    3130#include <dispatch/dispatch.h>
     31#include <wtf/Function.h>
     32#include <wtf/MessageQueue.h>
    3233#include <wtf/RetainPtr.h>
    3334
    … …  
    3637}
    3738
    38 @interface WebCoreResourceHandleAsOperationQueueDelegate : NSObject <NSURLConnectionDelegate, WebCoreResourceLoaderDelegate> {
     39@interface WebCoreResourceHandleAsOperationQueueDelegate : NSObject <NSURLConnectionDelegate> {
    3940    WebCore::ResourceHandle* m_handle;
    4041
    4142    // Synchronous delegates on operation queue wait until main thread sends an asynchronous response.
    4243    dispatch_semaphore_t m_semaphore;
     44    MessageQueue<Function<void()>>* m_messageQueue;
    4345    RetainPtr<NSURLRequest> m_requestResult;
    4446    RetainPtr<NSCachedURLResponse> m_cachedResponseResult;
    … …  
    4648}
    4749
    48 - (id)initWithHandle:(WebCore::ResourceHandle*)handle;
     50- (void)detachHandle;
     51- (id)initWithHandle:(WebCore::ResourceHandle*)handle messageQueue:(MessageQueue<Function<void()>>*)messageQueue;
    4952- (void)continueWillSendRequest:(NSURLRequest *)newRequest;
    5053- (void)continueDidReceiveResponse;
    51 #if USE(PROTECTION_SPACE_AUTH_CALLBACK)
    5254- (void)continueCanAuthenticateAgainstProtectionSpace:(BOOL)canAuthenticate;
    53 #endif
    5455- (void)continueWillCacheResponse:(NSCachedURLResponse *)response;
    5556@end

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

    r223408 r224267  
    3737#import "ResourceResponse.h"
    3838#import "SharedBuffer.h"
     39#import "SynchronousLoaderClient.h"
    3940#import "WebCoreURLResponse.h"
    4041#import <pal/spi/cf/CFNetworkSPI.h>
    … …  
    4546@implementation WebCoreResourceHandleAsOperationQueueDelegate
    4647
    47 - (id)initWithHandle:(ResourceHandle*)handle
     48- (id)initWithHandle:(ResourceHandle*)handle messageQueue:(MessageQueue<Function<void()>>*)messageQueue
    4849{
    4950    self = [self init];
    … …  
    5354    m_handle = handle;
    5455    m_semaphore = dispatch_semaphore_create(0);
     56    m_messageQueue = messageQueue;
    5557
    5658    return self;
    … …  
    114116#endif
    115117
    116     RetainPtr<id> protector(self);
    117 
    118     dispatch_async(dispatch_get_main_queue(), ^{
     118    auto work = [self = self, protectedSelf = RetainPtr<id>(self), newRequest = RetainPtr<NSURLRequest>(newRequest), redirectResponse = RetainPtr<NSURLResponse>(redirectResponse)] () mutable {
    119119        if (!m_handle) {
    120120            m_requestResult = nullptr;
    … …  
    123123        }
    124124
    125         m_handle->willSendRequest(newRequest, redirectResponse);
    126     });
     125        m_handle->willSendRequest(newRequest.get(), redirectResponse.get());
     126    };
     127
     128   
     129    if (m_messageQueue)
     130        m_messageQueue->append(std::make_unique<Function<void()>>(WTFMove(work)));
     131    else
     132        dispatch_async(dispatch_get_main_queue(), work);
    127133
    128134    dispatch_semaphore_wait(m_semaphore, DISPATCH_TIME_FOREVER);
    … …  
    137143    LOG(Network, "Handle %p delegate connection:%p didReceiveAuthenticationChallenge:%p", m_handle, connection, challenge);
    138144
    139     dispatch_async(dispatch_get_main_queue(), ^{
     145    auto work = [self, protectedSelf = RetainPtr<id>(self), challenge = RetainPtr<NSURLAuthenticationChallenge>(challenge)] () mutable {
    140146        if (!m_handle) {
    141             [[challenge sender] cancelAuthenticationChallenge:challenge];
    142             return;
    143         }
    144         m_handle->didReceiveAuthenticationChallenge(core(challenge));
    145     });
    146 }
    147 
    148 #if USE(PROTECTION_SPACE_AUTH_CALLBACK)
     147            [[challenge sender] cancelAuthenticationChallenge:challenge.get()];
     148            return;
     149        }
     150        m_handle->didReceiveAuthenticationChallenge(core(challenge.get()));
     151    };
     152
     153    if (m_messageQueue)
     154        m_messageQueue->append(std::make_unique<Function<void()>>(WTFMove(work)));
     155    else
     156        dispatch_async(dispatch_get_main_queue(), work);
     157}
     158
    149159- (BOOL)connection:(NSURLConnection *)connection canAuthenticateAgainstProtectionSpace:(NSURLProtectionSpace *)protectionSpace
    150160{
    … …  
    154164    LOG(Network, "Handle %p delegate connection:%p canAuthenticateAgainstProtectionSpace:%@://%@:%u realm:%@ method:%@ %@%@", m_handle, connection, [protectionSpace protocol], [protectionSpace host], [protectionSpace port], [protectionSpace realm], [protectionSpace authenticationMethod], [protectionSpace isProxy] ? @"proxy:" : @"", [protectionSpace isProxy] ? [protectionSpace proxyType] : @"");
    155165
    156     RetainPtr<id> protector(self);
    157 
    158     dispatch_async(dispatch_get_main_queue(), ^{
     166    auto work = [self = self, protectedSelf = RetainPtr<id>(self), protectionSpace = RetainPtr<NSURLProtectionSpace>(protectionSpace)] () mutable {
    159167        if (!m_handle) {
    160168            m_boolResult = NO;
    … …  
    162170            return;
    163171        }
    164         m_handle->canAuthenticateAgainstProtectionSpace(ProtectionSpace(protectionSpace));
    165     });
    166 
     172        m_handle->canAuthenticateAgainstProtectionSpace(ProtectionSpace(protectionSpace.get()));
     173    };
     174
     175    if (m_messageQueue)
     176        m_messageQueue->append(std::make_unique<Function<void()>>(WTFMove(work)));
     177    else
     178        dispatch_async(dispatch_get_main_queue(), work);
     179   
    167180    dispatch_semaphore_wait(m_semaphore, DISPATCH_TIME_FOREVER);
    168181    return m_boolResult;
    169182}
    170 #endif
    171183
    172184- (void)connection:(NSURLConnection *)connection didReceiveResponse:(NSURLResponse *)r
    … …  
    176188    LOG(Network, "Handle %p delegate connection:%p didReceiveResponse:%p (HTTP status %d, reported MIMEType '%s')", m_handle, connection, r, [r respondsToSelector:@selector(statusCode)] ? [(id)r statusCode] : 0, [[r MIMEType] UTF8String]);
    177189
    178     RetainPtr<id> protector(self);
    179 
    180     dispatch_async(dispatch_get_main_queue(), ^{
     190    auto work = [self = self, protectedSelf = RetainPtr<id>(self), r = RetainPtr<NSURLResponse>(r), connection = RetainPtr<NSURLConnection>(connection)] () mutable {
     191        RefPtr<ResourceHandle> protectedHandle(m_handle);
    181192        if (!m_handle || !m_handle->client()) {
    182193            dispatch_semaphore_signal(m_semaphore);
    … …  
    194205            [r _setMIMEType:@"text/html"];
    195206
    196         ResourceResponse resourceResponse(r);
    197         ResourceHandle::getConnectionTimingData(connection, resourceResponse.deprecatedNetworkLoadMetrics());
     207        ResourceResponse resourceResponse(r.get());
     208        resourceResponse.setSource(ResourceResponse::Source::Network);
     209        ResourceHandle::getConnectionTimingData(connection.get(), resourceResponse.deprecatedNetworkLoadMetrics());
    198210
    199211        m_handle->didReceiveResponse(WTFMove(resourceResponse));
    200     });
    201 
     212    };
     213
     214    if (m_messageQueue)
     215        m_messageQueue->append(std::make_unique<Function<void()>>(WTFMove(work)));
     216    else
     217        dispatch_async(dispatch_get_main_queue(), work);
     218   
    202219    dispatch_semaphore_wait(m_semaphore, DISPATCH_TIME_FOREVER);
    203220}
    … …  
    211228    LOG(Network, "Handle %p delegate connection:%p didReceiveData:%p lengthReceived:%lld", m_handle, connection, data, lengthReceived);
    212229
    213     dispatch_async(dispatch_get_main_queue(), ^{
     230    auto work = [self = self, protectedSelf = RetainPtr<id>(self), data = RetainPtr<NSData>(data)] () mutable {
    214231        if (!m_handle || !m_handle->client())
    215232            return;
    … …  
    221238        // -1 means we do not provide any data about transfer size to inspector so it would use
    222239        // Content-Length headers or content size to show transfer size.
    223         m_handle->client()->didReceiveBuffer(m_handle, SharedBuffer::create(data), -1);
    224     });
     240        m_handle->client()->didReceiveBuffer(m_handle, SharedBuffer::create(data.get()), -1);
     241    };
     242
     243    if (m_messageQueue)
     244        m_messageQueue->append(std::make_unique<Function<void()>>(WTFMove(work)));
     245    else
     246        dispatch_async(dispatch_get_main_queue(), work);
    225247}
    226248
    … …  
    233255    LOG(Network, "Handle %p delegate connection:%p didSendBodyData:%d totalBytesWritten:%d totalBytesExpectedToWrite:%d", m_handle, connection, bytesWritten, totalBytesWritten, totalBytesExpectedToWrite);
    234256
    235     dispatch_async(dispatch_get_main_queue(), ^{
     257    auto work = [self = self, protectedSelf = RetainPtr<id>(self), totalBytesWritten = totalBytesWritten, totalBytesExpectedToWrite = totalBytesExpectedToWrite] () mutable {
    236258        if (!m_handle || !m_handle->client())
    237259            return;
    238260        m_handle->client()->didSendData(m_handle, totalBytesWritten, totalBytesExpectedToWrite);
    239     });
     261    };
     262
     263    if (m_messageQueue)
     264        m_messageQueue->append(std::make_unique<Function<void()>>(WTFMove(work)));
     265    else
     266        dispatch_async(dispatch_get_main_queue(), work);
    240267}
    241268
    … …  
    247274    LOG(Network, "Handle %p delegate connectionDidFinishLoading:%p", m_handle, connection);
    248275
    249     dispatch_async(dispatch_get_main_queue(), ^{
     276    auto task = [self = self, protectedSelf = RetainPtr<id>(self)] () mutable {
    250277        if (!m_handle || !m_handle->client())
    251278            return;
    252279
    253280        m_handle->client()->didFinishLoading(m_handle);
    254     });
     281        if (m_messageQueue) {
     282            m_messageQueue->kill();
     283            m_messageQueue = nullptr;
     284        }
     285    };
     286
     287    if (m_messageQueue)
     288        m_messageQueue->append(std::make_unique<Function<void()>>(WTFMove(task)));
     289    else
     290        dispatch_async(dispatch_get_main_queue(), task);
    255291}
    256292
    … …  
    262298    LOG(Network, "Handle %p delegate connection:%p didFailWithError:%@", m_handle, connection, error);
    263299
    264     dispatch_async(dispatch_get_main_queue(), ^{
     300    auto work = [self = self, protectedSelf = RetainPtr<id>(self), error = RetainPtr<NSError>(error)] () mutable {
    265301        if (!m_handle || !m_handle->client())
    266302            return;
    267303
    268         m_handle->client()->didFail(m_handle, error);
    269     });
     304        m_handle->client()->didFail(m_handle, error.get());
     305        if (m_messageQueue) {
     306            m_messageQueue->kill();
     307            m_messageQueue = nullptr;
     308        }
     309    };
     310
     311    if (m_messageQueue)
     312        m_messageQueue->append(std::make_unique<Function<void()>>(WTFMove(work)));
     313    else
     314        dispatch_async(dispatch_get_main_queue(), work);
    270315}
    271316
    … …  
    278323    LOG(Network, "Handle %p delegate connection:%p willCacheResponse:%p", m_handle, connection, cachedResponse);
    279324
    280     RetainPtr<id> protector(self);
    281 
    282     dispatch_async(dispatch_get_main_queue(), ^{
     325    auto work = [self = self, protectedSelf = RetainPtr<id>(self), cachedResponse = RetainPtr<NSCachedURLResponse>(cachedResponse)] () mutable {
    283326        if (!m_handle || !m_handle->client()) {
    284327            m_cachedResponseResult = nullptr;
    … …  
    287330        }
    288331
    289         m_handle->client()->willCacheResponseAsync(m_handle, cachedResponse);
    290     });
     332        m_handle->client()->willCacheResponseAsync(m_handle, cachedResponse.get());
     333    };
     334
     335    if (m_messageQueue)
     336        m_messageQueue->append(std::make_unique<Function<void()>>(WTFMove(work)));
     337    else
     338        dispatch_async(dispatch_get_main_queue(), work);
    291339
    292340    dispatch_semaphore_wait(m_semaphore, DISPATCH_TIME_FOREVER);

  • trunk/Source/WebCore/platform/network/soup/ResourceHandleSoup.cpp

    r223728 r224267  
    354354
    355355    ResourceResponse responseCopy = d->m_response;
    356     if (d->client()->usesAsyncCallbacks())
    357         d->client()->willSendRequestAsync(handle, WTFMove(newRequest), WTFMove(responseCopy));
    358     else {
    359         auto request = d->client()->willSendRequest(handle, WTFMove(newRequest), WTFMove(responseCopy));
    360         continueAfterWillSendRequest(handle, WTFMove(request));
    361     }
    362 
     356    d->client()->willSendRequestAsync(handle, WTFMove(newRequest), WTFMove(responseCopy));
    363357}
    364358
    … …  
    10331027void ResourceHandle::continueWillSendRequest(ResourceRequest&& request)
    10341028{
    1035     ASSERT(!client() || client()->usesAsyncCallbacks());
    10361029    continueAfterWillSendRequest(this, WTFMove(request));
    10371030}
    … …  
    10391032void ResourceHandle::continueDidReceiveResponse()
    10401033{
    1041     ASSERT(!client() || client()->usesAsyncCallbacks());
    10421034    continueAfterDidReceiveResponse(this);
    10431035}

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

    r223408 r224267  
    7272}
    7373
     74void BlobDownloadClient::willSendRequestAsync(ResourceHandle*, ResourceRequest&&, ResourceResponse&&)
     75{
     76    ASSERT_NOT_REACHED();
     77}
     78
     79#if USE(PROTECTION_SPACE_AUTH_CALLBACK)
     80void BlobDownloadClient::canAuthenticateAgainstProtectionSpaceAsync(ResourceHandle*, const ProtectionSpace&)
     81{
     82    ASSERT_NOT_REACHED();
     83}
     84#endif
     85
    7486void BlobDownloadClient::didReceiveBuffer(ResourceHandle*, Ref<SharedBuffer>&& buffer, int)
    7587{

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

    r223408 r224267  
    5050    void didFinishLoading(WebCore::ResourceHandle*) final;
    5151    void didFail(WebCore::ResourceHandle*, const WebCore::ResourceError&) final;
    52     bool usesAsyncCallbacks() final { return true; }
     52    void willSendRequestAsync(WebCore::ResourceHandle*, WebCore::ResourceRequest&&, WebCore::ResourceResponse&&) final;
     53#if USE(PROTECTION_SPACE_AUTH_CALLBACK)
     54    void canAuthenticateAgainstProtectionSpaceAsync(WebCore::ResourceHandle*, const WebCore::ProtectionSpace&) final;
     55#endif
    5356
    5457    Download& m_download;

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

    r223791 r224267  
    252252
    253253    // PingHandle manages its own lifetime, deleting itself when its purpose has been fulfilled.
    254     new PingHandle(context.ptr(), loadParameters.request, loadParameters.storedCredentialsPolicy == StoredCredentialsPolicy::Use, PingHandle::UsesAsyncCallbacks::Yes, loadParameters.shouldFollowRedirects, WTFMove(completionHandler));
     254    new PingHandle(context.ptr(), loadParameters.request, loadParameters.storedCredentialsPolicy == StoredCredentialsPolicy::Use, loadParameters.shouldFollowRedirects, WTFMove(completionHandler));
    255255#endif
    256256}

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

    r224134 r224267  
    128128    void didReceiveAuthenticationChallenge(WebCore::ResourceHandle*, const WebCore::AuthenticationChallenge&) final;
    129129    void receivedCancellation(WebCore::ResourceHandle*, const WebCore::AuthenticationChallenge&) final;
    130     bool usesAsyncCallbacks() final { return true; }
    131130    bool loadingSynchronousXHR() final { return m_client.get().isSynchronous(); }
    132131#else

  • trunk/Source/WebKit/Shared/mac/ArgumentCodersMac.h

    r223408 r224267  
    2424 */
    2525
    26 #ifndef ArgumentCodersMac_h
    27 #define ArgumentCodersMac_h
     26#pragma once
    2827
     28#include <objc/objc.h>
    2929#include <wtf/RetainPtr.h>
    3030
    … …  
    9494
    9595} // namespace IPC
    96 
    97 #endif // ArgumentCodersMac_h

  • trunk/Source/WebKit/Shared/mac/WebCoreArgumentCodersMac.mm

    r224023 r224267  
    174174}
    175175
    176 static RetainPtr<CFDictionaryRef> createSerializableRepresentation(NSURLRequest *request, CFTypeRef tokenNull)
    177 {
    178     return createSerializableRepresentation([request _CFURLRequest], tokenNull);
    179 }
    180 
    181 static RetainPtr<NSURLRequest> createNSURLRequestFromSerializableRepresentation(CFDictionaryRef representation, CFTypeRef tokenNull)
    182 {
    183     auto cfRequest = createCFURLRequestFromSerializableRepresentation(representation, tokenNull);
    184     if (!cfRequest)
    185         return nullptr;
    186 
    187     return adoptNS([[NSURLRequest alloc] _initWithCFURLRequest:cfRequest.get()]);
    188 }
    189 
    190176#if USE(CFURLCONNECTION)
    191177void ArgumentCoder<ResourceRequest>::encodePlatformData(Encoder& encoder, const ResourceRequest& resourceRequest)
    … …  
    218204    encoder.encodeEnum(resourceRequest.cachePolicy());
    219205}
     206
    220207#else
     208
     209static RetainPtr<CFDictionaryRef> createSerializableRepresentation(NSURLRequest *request, CFTypeRef tokenNull)
     210{
     211    return createSerializableRepresentation([request _CFURLRequest], tokenNull);
     212}
     213
     214static RetainPtr<NSURLRequest> createNSURLRequestFromSerializableRepresentation(CFDictionaryRef representation, CFTypeRef tokenNull)
     215{
     216    auto cfRequest = createCFURLRequestFromSerializableRepresentation(representation, tokenNull);
     217    if (!cfRequest)
     218        return nullptr;
     219   
     220    return adoptNS([[NSURLRequest alloc] _initWithCFURLRequest:cfRequest.get()]);
     221}
     222   
    221223void ArgumentCoder<ResourceRequest>::encodePlatformData(Encoder& encoder, const ResourceRequest& resourceRequest)
    222224{

  • trunk/Source/WebKitLegacy/ChangeLog

    r223408 r224267  
     12017-10-31  Alex Christensen  <achristensen@webkit.org>
     2
     3        Use asynchronous ResourceHandleClient calls for WebKit1
     4        https://bugs.webkit.org/show_bug.cgi?id=160677
     5
     6        Reviewed by Brady Eidson.
     7
     8        * WebCoreSupport/WebResourceLoadScheduler.cpp:
     9        (WebResourceLoadScheduler::createPingHandle):
     10
    1112017-10-16  Ryan Haddad  <ryanhaddad@apple.com>
    212

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

    r223408 r224267  
    364364{
    365365    // PingHandle manages its own lifetime, deleting itself when its purpose has been fulfilled.
    366     new PingHandle(frame.loader().networkingContext(), request, options.credentials != FetchOptions::Credentials::Omit, PingHandle::UsesAsyncCallbacks::No, options.redirect == FetchOptions::Redirect::Follow, WTFMove(completionHandler));
     366    new PingHandle(frame.loader().networkingContext(), request, options.credentials != FetchOptions::Credentials::Omit, options.redirect == FetchOptions::Redirect::Follow, WTFMove(completionHandler));
    367367}
    368368

  • trunk/Tools/ChangeLog

    r224266 r224267  
     12017-10-31  Alex Christensen  <achristensen@webkit.org>
     2
     3        Use asynchronous ResourceHandleClient calls for WebKit1
     4        https://bugs.webkit.org/show_bug.cgi?id=160677
     5
     6        Reviewed by Brady Eidson.
     7
     8        * TestWebKitAPI/Tests/mac/SimplifyMarkup.mm:
     9        (TestWebKitAPI::TEST):
     10        The HTML being loaded contains an iframe, so testing if the main resource has loaded doesn't necessarily mean all subresources are loaded.
     11        Wait until they are loaded before continuing the test.  This is a test of editing commands once the page has loaded, not a test of loading.
     12
    1132017-10-31  Commit Queue  <commit-queue@webkit.org>
    214

  • trunk/Tools/TestWebKitAPI/Tests/mac/SimplifyMarkup.mm

    r223625 r224267  
    6565    Util::run(&didFinishLoad);
    6666    didFinishLoad = false;
     67    while (![[[[webView1 mainFrameDocument] body] innerHTML] isEqualToString:[[[webView2 mainFrameDocument] body] innerHTML]])
     68        Util::spinRunLoop(1);
    6769
    6870    DOMDocument *document1 = webView1.get().mainFrameDocument;
Note: See TracChangeset for help on using the changeset viewer.