Changeset 223271 in webkit


Ignore:
Timestamp:
Oct 12, 2017 6:55:24 PM (7 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):

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
48 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r223265 r223271  
     12017-10-12  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-12  Youenn Fablet  <youenn@apple.com>
    233

  • trunk/LayoutTests/TestExpectations

    r223265 r223271  
    4040# window.showModalDialog is only tested in DumpRenderTree on Mac.
    4141editing/execCommand/show-modal-dialog-during-execCommand.html [ Skip ]
     42http/tests/security/cross-origin-modal-dialog-base.html [ Skip ]
     43fast/events/scroll-event-during-modal-dialog.html [ Skip ]
     44fast/harness/show-modal-dialog.html [ Skip ]
    4245
    4346fast/shadow-dom/touch-event-on-text-assigned-to-slot.html [ Skip ]
    … …  
    435438webkit.org/b/169565 imported/w3c/web-platform-tests/cors/status-async.htm [ Failure ]
    436439webkit.org/b/169565 imported/w3c/web-platform-tests/cors/304.htm [ Failure ]
     440
     441# These tests used to have deterministic load delegate callback order before webkit.org/b/160677
     442http/tests/svg/svg-use-external.html [ Pass Failure ]
     443http/tests/loading/text-content-type-with-binary-extension.html [ Pass Failure ]
     444http/tests/security/contentSecurityPolicy/block-all-mixed-content/insecure-iframe-in-main-frame.html [ Pass Failure ]
    437445
    438446# Tests that are flakey due to unhandled promise rejection error messages
    … …  
    770778webkit.org/b/140043 js/dom/Promise.html [ Pass Failure ]
    771779
     780webkit.org/b/134550 http/tests/cache/iframe-304-crash.html [ Failure Pass ]
    772781webkit.org/b/141267 http/tests/misc/detached-frame-console.html [ Pass Failure ]
    773782

  • trunk/LayoutTests/platform/gtk/TestExpectations

    r223253 r223271  
    16501650webkit.org/b/36642 fast/replaced/border-radius-clip.html [ Failure Pass Crash ]
    16511651
    1652 webkit.org/b/134550 http/tests/cache/iframe-304-crash.html [ Failure Pass ]
    1653 
    16541652webkit.org/b/134573 media/track/audio-track.html [ Failure Timeout Pass ]
    16551653webkit.org/b/134576 media/track/audio/audio-track-mkv-vorbis-language.html [ Failure Timeout Pass ]

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

    r223160 r223271  
    447447
    448448# HTTP tests that are flaky:
    449 http/tests/cache/iframe-304-crash.html [ Failure Pass ]
    450449http/tests/navigation/forward-and-cancel.html [ Failure Pass ]
    451450http/tests/security/xss-DENIED-xsl-external-entity-redirect.xml [ Failure Pass ]

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

    r223243 r223271  
    298298webkit.org/b/162999 accessibility/mac/wk1-set-selected-text-marker-range-input-element.html [ Skip ]
    299299
    300 webkit.org/b/134550 http/tests/cache/iframe-304-crash.html [ Pass Failure ]
    301 
    302300# testRunner.setUseDeferredFrameLoading is not implemented.
    303301webkit.org/b/93980 http/tests/appcache/load-from-appcache-defer-resume-crash.html [ Skip ]

  • trunk/LayoutTests/platform/wk2/TestExpectations

    r223253 r223271  
    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

    r222623 r223271  
    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

    r115773 r223271  
    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

    r223264 r223271  
     12017-10-12  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-12  Chris Dumez  <cdumez@apple.com>
    2108

  • trunk/Source/WebCore/PlatformAppleWin.cmake

    r222326 r223271  
    6161    platform/network/cf/ResourceHandleCFNet.cpp
    6262    platform/network/cf/ResourceHandleCFURLConnectionDelegate.cpp
     63    platform/network/cf/ResourceHandleCFURLConnectionDelegateWithOperationQueue.cpp
    6364    platform/network/cf/ResourceRequestCFNet.cpp
    6465    platform/network/cf/ResourceResponseCFNet.cpp
    6566    platform/network/cf/SocketStreamHandleImplCFNet.cpp
    6667    platform/network/cf/SynchronousLoaderClientCFNet.cpp
    67     platform/network/cf/SynchronousResourceHandleCFURLConnectionDelegate.cpp
    6868)
    6969

  • trunk/Source/WebCore/PlatformMac.cmake

    r222917 r223271  
    563563    platform/network/mac/SynchronousLoaderClient.mm
    564564    platform/network/mac/UTIUtilities.mm
    565     platform/network/mac/WebCoreResourceHandleAsDelegate.mm
    566565    platform/network/mac/WebCoreResourceHandleAsOperationQueueDelegate.mm
    567566    platform/network/mac/WebCoreURLResponse.mm

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

    r223237 r223271  
    11151115                26FAE4CC1852E3A5004C8C46 /* ResourceHandleCFURLConnectionDelegate.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26FAE4C81852E3A5004C8C46 /* ResourceHandleCFURLConnectionDelegate.cpp */; };
    11161116                26FAE4CD1852E3A5004C8C46 /* ResourceHandleCFURLConnectionDelegate.h in Headers */ = {isa = PBXBuildFile; fileRef = 26FAE4C91852E3A5004C8C46 /* ResourceHandleCFURLConnectionDelegate.h */; };
    1117                 26FAE4CE1852E3A5004C8C46 /* SynchronousResourceHandleCFURLConnectionDelegate.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26FAE4CA1852E3A5004C8C46 /* SynchronousResourceHandleCFURLConnectionDelegate.cpp */; };
    1118                 26FAE4CF1852E3A5004C8C46 /* SynchronousResourceHandleCFURLConnectionDelegate.h in Headers */ = {isa = PBXBuildFile; fileRef = 26FAE4CB1852E3A5004C8C46 /* SynchronousResourceHandleCFURLConnectionDelegate.h */; };
    11191117                2914E3071CAB5A440049966F /* AccessibilityAttachment.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2914E3051CAB5A440049966F /* AccessibilityAttachment.cpp */; };
    11201118                2914E3081CAB5A440049966F /* AccessibilityAttachment.h in Headers */ = {isa = PBXBuildFile; fileRef = 2914E3061CAB5A440049966F /* AccessibilityAttachment.h */; };
    … …  
    67206718                E17B492116A9B8FF001C8839 /* JSTransitionEvent.h in Headers */ = {isa = PBXBuildFile; fileRef = E17B491F16A9B8FF001C8839 /* JSTransitionEvent.h */; };
    67216719                E17B492216A9B8FF001C8839 /* JSTransitionEvent.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E17B492016A9B8FF001C8839 /* JSTransitionEvent.cpp */; };
    6722                 E180810E16FCECDF00B80D07 /* WebCoreResourceHandleAsDelegate.mm in Sources */ = {isa = PBXBuildFile; fileRef = E180810C16FCECDF00B80D07 /* WebCoreResourceHandleAsDelegate.mm */; };
    6723                 E180810F16FCECDF00B80D07 /* WebCoreResourceHandleAsDelegate.h in Headers */ = {isa = PBXBuildFile; fileRef = E180810D16FCECDF00B80D07 /* WebCoreResourceHandleAsDelegate.h */; };
    67246720                E180811216FCF42F00B80D07 /* SynchronousLoaderClient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E180811016FCF42E00B80D07 /* SynchronousLoaderClient.cpp */; };
    67256721                E180811616FCF9CB00B80D07 /* SynchronousLoaderClient.mm in Sources */ = {isa = PBXBuildFile; fileRef = E180811416FCF9CB00B80D07 /* SynchronousLoaderClient.mm */; };
    … …  
    87918787                26FAE4C81852E3A5004C8C46 /* ResourceHandleCFURLConnectionDelegate.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ResourceHandleCFURLConnectionDelegate.cpp; sourceTree = "<group>"; };
    87928788                26FAE4C91852E3A5004C8C46 /* ResourceHandleCFURLConnectionDelegate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ResourceHandleCFURLConnectionDelegate.h; sourceTree = "<group>"; };
    8793                 26FAE4CA1852E3A5004C8C46 /* SynchronousResourceHandleCFURLConnectionDelegate.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SynchronousResourceHandleCFURLConnectionDelegate.cpp; sourceTree = "<group>"; };
    8794                 26FAE4CB1852E3A5004C8C46 /* SynchronousResourceHandleCFURLConnectionDelegate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SynchronousResourceHandleCFURLConnectionDelegate.h; sourceTree = "<group>"; };
    87958789                2914E3051CAB5A440049966F /* AccessibilityAttachment.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = AccessibilityAttachment.cpp; sourceTree = "<group>"; };
    87968790                2914E3061CAB5A440049966F /* AccessibilityAttachment.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AccessibilityAttachment.h; sourceTree = "<group>"; };
    … …  
    1556315557                E17B491F16A9B8FF001C8839 /* JSTransitionEvent.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSTransitionEvent.h; sourceTree = "<group>"; };
    1556415558                E17B492016A9B8FF001C8839 /* JSTransitionEvent.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSTransitionEvent.cpp; sourceTree = "<group>"; };
    15565                 E180810C16FCECDF00B80D07 /* WebCoreResourceHandleAsDelegate.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WebCoreResourceHandleAsDelegate.mm; sourceTree = "<group>"; };
    15566                 E180810D16FCECDF00B80D07 /* WebCoreResourceHandleAsDelegate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebCoreResourceHandleAsDelegate.h; sourceTree = "<group>"; };
    1556715559                E180811016FCF42E00B80D07 /* SynchronousLoaderClient.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SynchronousLoaderClient.cpp; sourceTree = "<group>"; };
    1556815560                E180811416FCF9CB00B80D07 /* SynchronousLoaderClient.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = SynchronousLoaderClient.mm; sourceTree = "<group>"; };
    … …  
    1964319635                                1FAFBF1615A5FA5200083A20 /* UTIUtilities.h */,
    1964419636                                1FAFBF1715A5FA5200083A20 /* UTIUtilities.mm */,
    19645                                 E180810D16FCECDF00B80D07 /* WebCoreResourceHandleAsDelegate.h */,
    19646                                 E180810C16FCECDF00B80D07 /* WebCoreResourceHandleAsDelegate.mm */,
    1964719637                                E152551316FD234F003D7ADB /* WebCoreResourceHandleAsOperationQueueDelegate.h */,
    1964819638                                E152551416FD234F003D7ADB /* WebCoreResourceHandleAsOperationQueueDelegate.mm */,
    … …  
    2416624156                                51ABAE1D103C1913008C5260 /* SocketStreamHandleImplCFNet.cpp */,
    2416724157                                442ABCD517D9262F00D30715 /* SynchronousLoaderClientCFNet.cpp */,
    24168                                 26FAE4CA1852E3A5004C8C46 /* SynchronousResourceHandleCFURLConnectionDelegate.cpp */,
    24169                                 26FAE4CB1852E3A5004C8C46 /* SynchronousResourceHandleCFURLConnectionDelegate.h */,
    2417024158                        );
    2417124159                        path = cf;
    … …  
    3061930607                                517A53461F50C17F00DCDC0A /* SWServerWorker.h in Headers */,
    3062030608                                E180811716FCF9CB00B80D07 /* SynchronousLoaderClient.h in Headers */,
    30621                                 26FAE4CF1852E3A5004C8C46 /* SynchronousResourceHandleCFURLConnectionDelegate.h in Headers */,
    3062230609                                0F03C0741884695E00A5F8CA /* SystemMemory.h in Headers */,
    3062330610                                5D5975B319635F1100D00878 /* SystemVersion.h in Headers */,
    … …  
    3085230839                                DD05FE0D0B8BA3C6009ACDFE /* WebCoreObjCExtras.h in Headers */,
    3085330840                                EDEC98030AED7E170059137F /* WebCorePrefix.h in Headers */,
    30854                                 E180810F16FCECDF00B80D07 /* WebCoreResourceHandleAsDelegate.h in Headers */,
    3085530841                                E152551516FD2350003D7ADB /* WebCoreResourceHandleAsOperationQueueDelegate.h in Headers */,
    3085630842                                A14832C7187F66C800DA63A6 /* WebCoreThread.h in Headers */,
    … …  
    3443334419                                E180811616FCF9CB00B80D07 /* SynchronousLoaderClient.mm in Sources */,
    3443434420                                442ABCD617D9262F00D30715 /* SynchronousLoaderClientCFNet.cpp in Sources */,
    34435                                 26FAE4CE1852E3A5004C8C46 /* SynchronousResourceHandleCFURLConnectionDelegate.cpp in Sources */,
    3443634421                                E45390AE0EAFF4B5003695C8 /* SystemMemoryIOS.cpp in Sources */,
    3443734422                                5D5975B419635F1100D00878 /* SystemVersion.mm in Sources */,
    … …  
    3464634631                                B50F5B810E96CD9900AD71A6 /* WebCoreObjCExtras.mm in Sources */,
    3464734632                                9BDD18271F7E05F400E8E577 /* WebCorePasteboardFileReader.cpp in Sources */,
    34648                                 E180810E16FCECDF00B80D07 /* WebCoreResourceHandleAsDelegate.mm in Sources */,
    3464934633                                E152551616FD2350003D7ADB /* WebCoreResourceHandleAsOperationQueueDelegate.mm in Sources */,
    3465034634                                A14832C8187F673F00DA63A6 /* WebCoreThread.mm in Sources */,

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

    r222239 r223271  
    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

    r222602 r223271  
    619619}
    620620
    621 ResourceRequest ResourceLoader::willSendRequest(ResourceHandle*, ResourceRequest&& request, ResourceResponse&& redirectResponse)
    622 {
    623     if (documentLoader()->applicationCacheHost().maybeLoadFallbackForRedirect(this, request, redirectResponse))
    624         return WTFMove(request);
     621void ResourceLoader::willSendRequestAsync(ResourceHandle* handle, ResourceRequest&& request, ResourceResponse&& redirectResponse)
     622{
     623    RefPtr<ResourceHandle> protectedHandle(handle);
     624    if (documentLoader()->applicationCacheHost().maybeLoadFallbackForRedirect(this, request, redirectResponse)) {
     625        handle->continueWillSendRequest(WTFMove(request));
     626        return;
     627    }
    625628    willSendRequestInternal(request, redirectResponse);
    626     return WTFMove(request);
     629    handle->continueWillSendRequest(WTFMove(request));
    627630}
    628631
    … …  
    632635}
    633636
    634 void ResourceLoader::didReceiveResponse(ResourceHandle*, ResourceResponse&& response)
    635 {
    636     if (documentLoader()->applicationCacheHost().maybeLoadFallbackForResponse(this, response))
    637         return;
     637void ResourceLoader::didReceiveResponseAsync(ResourceHandle* handle, ResourceResponse&& response)
     638{
     639    if (documentLoader()->applicationCacheHost().maybeLoadFallbackForResponse(this, response)) {
     640        handle->continueDidReceiveResponse();
     641        return;
     642    }
    638643    didReceiveResponse(response);
     644    handle->continueDidReceiveResponse();
    639645}
    640646
    … …  
    707713
    708714#if USE(PROTECTION_SPACE_AUTH_CALLBACK)
     715void ResourceLoader::canAuthenticateAgainstProtectionSpaceAsync(ResourceHandle* handle, const ProtectionSpace& protectionSpace)
     716{
     717    handle->continueCanAuthenticateAgainstProtectionSpace(canAuthenticateAgainstProtectionSpace(protectionSpace));
     718}
    709719
    710720bool ResourceLoader::canAuthenticateAgainstProtectionSpace(const ProtectionSpace& protectionSpace)

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

    r219336 r223271  
    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

    r223238 r223271  
    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

    r212993 r223271  
    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

    r215686 r223271  
    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
    … …  
    160180void BlobResourceHandle::continueDidReceiveResponse()
    161181{
    162     ASSERT(m_async);
    163     ASSERT(usesAsyncCallbacks());
    164 
    165182    m_buffer.resize(bufferSize);
    166183    readAsync();
    … …  
    229246            Ref<BlobResourceHandle> protectedThis(*this);
    230247            notifyResponse();
    231             if (!usesAsyncCallbacks()) {
    232                 m_buffer.resize(bufferSize);
    233                 readAsync();
    234             }
    235248        }
    236249        return;
    … …  
    423436{
    424437    ASSERT(isMainThread());
    425     ASSERT(m_async);
    426438
    427439    // Do not continue if the request is aborted or an error occurs.
    … …  
    447459{
    448460    ASSERT(isMainThread());
    449     ASSERT(m_async);
    450461    ASSERT(item.data().data());
    451462
    … …  
    462473{
    463474    ASSERT(isMainThread());
    464     ASSERT(m_async);
    465475
    466476    if (m_fileOpened) {
    … …  
    576586    // Notably, this will affect a name suggested in "File Save As".
    577587
    578     didReceiveResponse(WTFMove(response));
     588    client()->didReceiveResponseAsync(this, WTFMove(response));
    579589}
    580590
    … …  
    599609    }
    600610
    601     didReceiveResponse(WTFMove(response));
     611    client()->didReceiveResponseAsync(this, WTFMove(response));
    602612}
    603613

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

    r222739 r223271  
    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

    r222756 r223271  
    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

    r222467 r223271  
    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

    r207151 r223271  
    4040{
    4141}
    42    
    43 ResourceRequest ResourceHandleClient::willSendRequest(ResourceHandle*, ResourceRequest&& request, ResourceResponse&&)
    44 {
    45     return WTFMove(request);
    46 }
    47 
    48 void ResourceHandleClient::willSendRequestAsync(ResourceHandle* handle, ResourceRequest&& request, ResourceResponse&& /*redirectResponse*/)
    49 {
    50     handle->continueWillSendRequest(WTFMove(request));
    51 }
    52 
    53 void ResourceHandleClient::didReceiveResponseAsync(ResourceHandle* handle, ResourceResponse&&)
    54 {
    55     handle->continueDidReceiveResponse();
    56 }
    57 
    58 #if USE(PROTECTION_SPACE_AUTH_CALLBACK)
    59 void ResourceHandleClient::canAuthenticateAgainstProtectionSpaceAsync(ResourceHandle* handle, const ProtectionSpace&)
    60 {
    61     handle->continueCanAuthenticateAgainstProtectionSpace(false);
    62 }
    63 #endif
    6442
    6543#if USE(CFURLCONNECTION)

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

    r215280 r223271  
    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

    r220939 r223271  
    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

    r212993 r223271  
    3737}
    3838
    39 ResourceRequest SynchronousLoaderClient::willSendRequest(ResourceHandle* handle, ResourceRequest&& request, ResourceResponse&&)
     39void SynchronousLoaderClient::willSendRequestAsync(ResourceHandle* handle, ResourceRequest&& request, ResourceResponse&&)
    4040{
    4141    // FIXME: This needs to be fixed to follow the redirect correctly even for cross-domain requests.
    42     if (protocolHostAndPortAreEqual(handle->firstRequest().url(), request.url()))
    43         return WTFMove(request);
     42    if (protocolHostAndPortAreEqual(handle->firstRequest().url(), request.url())) {
     43        handle->continueWillSendRequest(WTFMove(request));
     44        return;
     45    }
    4446
    4547    ASSERT(m_error.isNull());
    4648    m_error = platformBadResponseError();
    47     m_isDone = true;
    48     return { };
     49    handle->continueWillSendRequest({ });
    4950}
    5051
    … …  
    5657
    5758#if USE(PROTECTION_SPACE_AUTH_CALLBACK)
    58 bool SynchronousLoaderClient::canAuthenticateAgainstProtectionSpace(ResourceHandle*, const ProtectionSpace&)
     59void SynchronousLoaderClient::canAuthenticateAgainstProtectionSpaceAsync(ResourceHandle* handle, const ProtectionSpace&)
    5960{
    6061    // FIXME: We should ask FrameLoaderClient. <http://webkit.org/b/65196>
    61     return true;
     62    handle->continueCanAuthenticateAgainstProtectionSpace(true);
    6263}
    6364#endif
    6465
    65 void SynchronousLoaderClient::didReceiveResponse(ResourceHandle*, ResourceResponse&& response)
     66void SynchronousLoaderClient::didReceiveResponseAsync(ResourceHandle* handle, ResourceResponse&& response)
    6667{
    6768    m_response = WTFMove(response);
     69    handle->continueDidReceiveResponse();
    6870}
    6971
    … …  
    7577void SynchronousLoaderClient::didFinishLoading(ResourceHandle*)
    7678{
    77     m_isDone = true;
     79    m_messageQueue.kill();
    7880}
    7981
    … …  
    8385
    8486    m_error = error;
    85     m_isDone = true;
     87   
     88    m_messageQueue.kill();
    8689}
    8790

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

    r212993 r223271  
    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

    r222938 r223271  
    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

    r219537 r223271  
    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

    r222898 r223271  
    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

    r222898 r223271  
    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 {
     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())
     230            return;
     231       
     232        LOG(Network, "CFNet - ResourceHandleCFURLConnectionDelegateWithOperationQueue::didReceiveData(handle=%p) (%s)", handle, handle->firstRequest().url().string().utf8().data());
     233
     234        handle->client()->didReceiveBuffer(handle, SharedBuffer::create(data.get()), originalLength);
     235    };
     236   
     237    if (m_messageQueue)
     238        m_messageQueue->append(std::make_unique<Function<void()>>(WTFMove(work)));
     239    else
     240        callOnMainThread(WTFMove(work));
     241}
     242
     243void ResourceHandleCFURLConnectionDelegateWithOperationQueue::didFinishLoading()
     244{
     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        }
     251
     252        LOG(Network, "CFNet - ResourceHandleCFURLConnectionDelegateWithOperationQueue::didFinishLoading(handle=%p) (%s)", handle, handle->firstRequest().url().string().utf8().data());
     253
     254        handle->client()->didFinishLoading(handle);
     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));
     266}
     267
     268void ResourceHandleCFURLConnectionDelegateWithOperationQueue::didFail(CFErrorRef error)
     269{
     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        }
     276       
     277        LOG(Network, "CFNet - ResourceHandleCFURLConnectionDelegateWithOperationQueue::didFail(handle=%p) (%s)", handle, handle->firstRequest().url().string().utf8().data());
     278
     279        handle->client()->didFail(handle, ResourceError(error.get()));
     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));
     291}
     292
     293CFCachedURLResponseRef ResourceHandleCFURLConnectionDelegateWithOperationQueue::willCacheResponse(CFCachedURLResponseRef cachedResponse)
     294{
     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()) {
     311            protectedThis->continueWillCacheResponse(nullptr);
     312            return;
     313        }
     314
     315        LOG(Network, "CFNet - ResourceHandleCFURLConnectionDelegateWithOperationQueue::willCacheResponse(handle=%p) (%s)", handle, handle->firstRequest().url().string().utf8().data());
     316
     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()));
     325    return m_cachedResponseResult.leakRef();
     326}
     327
     328void ResourceHandleCFURLConnectionDelegateWithOperationQueue::didReceiveChallenge(CFURLAuthChallengeRef challenge)
     329{
     330    auto work = [protectedThis = makeRef(*this), challenge = RetainPtr<CFURLAuthChallengeRef>(challenge)] () mutable {
     331        auto& handle = protectedThis->m_handle;
     332        if (!protectedThis->hasHandle())
     333            return;
     334       
     335        LOG(Network, "CFNet - ResourceHandleCFURLConnectionDelegateWithOperationQueue::didReceiveChallenge(handle=%p) (%s)", handle, handle->firstRequest().url().string().utf8().data());
     336
     337        handle->didReceiveAuthenticationChallenge(AuthenticationChallenge(challenge.get(), handle));
     338    };
     339
     340    if (m_messageQueue)
     341        m_messageQueue->append(std::make_unique<Function<void()>>(WTFMove(work)));
     342    else
     343        callOnMainThread(WTFMove(work));
     344}
     345
     346void ResourceHandleCFURLConnectionDelegateWithOperationQueue::didSendBodyData(CFIndex totalBytesWritten, CFIndex totalBytesExpectedToWrite)
     347{
     348    auto work = [protectedThis = makeRef(*this), totalBytesWritten, totalBytesExpectedToWrite] () mutable {
    186349        auto& handle = protectedThis->m_handle;
    187350        if (!protectedThis->hasHandle() || !handle->client())
    188351            return;
    189        
    190         LOG(Network, "CFNet - ResourceHandleCFURLConnectionDelegateWithOperationQueue::didReceiveData(handle=%p) (%s)", handle, handle->firstRequest().url().string().utf8().data());
    191 
    192         handle->client()->didReceiveBuffer(handle, SharedBuffer::create(data.get()), originalLength);
    193     });
    194 }
    195 
    196 void ResourceHandleCFURLConnectionDelegateWithOperationQueue::didFinishLoading()
    197 {
    198     callOnMainThread([protectedThis = makeRef(*this)] () mutable {
    199         auto& handle = protectedThis->m_handle;
    200         if (!protectedThis->hasHandle() || !handle->client())
    201             return;
    202 
    203         LOG(Network, "CFNet - ResourceHandleCFURLConnectionDelegateWithOperationQueue::didFinishLoading(handle=%p) (%s)", handle, handle->firstRequest().url().string().utf8().data());
    204 
    205         handle->client()->didFinishLoading(handle);
    206     });
    207 }
    208 
    209 void ResourceHandleCFURLConnectionDelegateWithOperationQueue::didFail(CFErrorRef error)
    210 {
    211     callOnMainThread([protectedThis = makeRef(*this), error = RetainPtr<CFErrorRef>(error)] () mutable {
    212         auto& handle = protectedThis->m_handle;
    213         if (!protectedThis->hasHandle() || !handle->client())
    214             return;
    215        
    216         LOG(Network, "CFNet - ResourceHandleCFURLConnectionDelegateWithOperationQueue::didFail(handle=%p) (%s)", handle, handle->firstRequest().url().string().utf8().data());
    217 
    218         handle->client()->didFail(handle, ResourceError(error.get()));
    219     });
    220 }
    221 
    222 CFCachedURLResponseRef ResourceHandleCFURLConnectionDelegateWithOperationQueue::willCacheResponse(CFCachedURLResponseRef cachedResponse)
    223 {
    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()) {
    235             protectedThis->continueWillCacheResponse(nullptr);
    236             return;
    237         }
    238 
    239         LOG(Network, "CFNet - ResourceHandleCFURLConnectionDelegateWithOperationQueue::willCacheResponse(handle=%p) (%s)", handle, handle->firstRequest().url().string().utf8().data());
    240 
    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);
    247     return m_cachedResponseResult.leakRef();
    248 }
    249 
    250 void ResourceHandleCFURLConnectionDelegateWithOperationQueue::didReceiveChallenge(CFURLAuthChallengeRef challenge)
    251 {
    252     callOnMainThread([protectedThis = makeRef(*this), challenge = RetainPtr<CFURLAuthChallengeRef>(challenge)] () mutable {
    253         auto& handle = protectedThis->m_handle;
    254         if (!protectedThis->hasHandle())
    255             return;
    256        
    257         LOG(Network, "CFNet - ResourceHandleCFURLConnectionDelegateWithOperationQueue::didReceiveChallenge(handle=%p) (%s)", handle, handle->firstRequest().url().string().utf8().data());
    258 
    259         handle->didReceiveAuthenticationChallenge(AuthenticationChallenge(challenge.get(), handle));
    260     });
    261 }
    262 
    263 void ResourceHandleCFURLConnectionDelegateWithOperationQueue::didSendBodyData(CFIndex totalBytesWritten, CFIndex totalBytesExpectedToWrite)
    264 {
    265     callOnMainThread([protectedThis = makeRef(*this), totalBytesWritten, totalBytesExpectedToWrite] () mutable {
    266         auto& handle = protectedThis->m_handle;
    267         if (!protectedThis->hasHandle() || !handle->client())
    268             return;
    269352
    270353        LOG(Network, "CFNet - ResourceHandleCFURLConnectionDelegateWithOperationQueue::didSendBodyData(handle=%p) (%s)", handle, handle->firstRequest().url().string().utf8().data());
    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

    r215280 r223271  
    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

    r222898 r223271  
    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

    r222397 r223271  
    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

    r222756 r223271  
    277277{
    278278    ASSERT(isMainThread());
    279     ASSERT(!client() || client()->usesAsyncCallbacks());
    280279
    281280    if (d->m_delegate)

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

    r222828 r223271  
    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

    r222938 r223271  
    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

    r222898 r223271  
    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

    r207585 r223271  
    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

    r220243 r223271  
    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

    r222467 r223271  
    356356
    357357    ResourceResponse responseCopy = d->m_response;
    358     if (d->client()->usesAsyncCallbacks())
    359         d->client()->willSendRequestAsync(handle, WTFMove(newRequest), WTFMove(responseCopy));
    360     else {
    361         auto request = d->client()->willSendRequest(handle, WTFMove(newRequest), WTFMove(responseCopy));
    362         continueAfterWillSendRequest(handle, WTFMove(request));
    363     }
    364 
     358    d->client()->willSendRequestAsync(handle, WTFMove(newRequest), WTFMove(responseCopy));
    365359}
    366360
    … …  
    10351029void ResourceHandle::continueWillSendRequest(ResourceRequest&& request)
    10361030{
    1037     ASSERT(!client() || client()->usesAsyncCallbacks());
    10381031    continueAfterWillSendRequest(this, WTFMove(request));
    10391032}
    … …  
    10411034void ResourceHandle::continueDidReceiveResponse()
    10421035{
    1043     ASSERT(!client() || client()->usesAsyncCallbacks());
    10441036    continueAfterDidReceiveResponse(this);
    10451037}

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

    r212993 r223271  
    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

    r212993 r223271  
    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

    r223207 r223271  
    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

    r222673 r223271  
    126126    void didReceiveAuthenticationChallenge(WebCore::ResourceHandle*, const WebCore::AuthenticationChallenge&) final;
    127127    void receivedCancellation(WebCore::ResourceHandle*, const WebCore::AuthenticationChallenge&) final;
    128     bool usesAsyncCallbacks() final { return true; }
    129128    bool loadingSynchronousXHR() final { return m_client.get().isSynchronous(); }
    130129#else

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

    r204668 r223271  
    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

    r222896 r223271  
    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

    r223149 r223271  
     12017-10-12  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-10  Sam Weinig  <sam@webkit.org>
    212

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

    r223149 r223271  
    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
Note: See TracChangeset for help on using the changeset viewer.