+2018-07-27 Alex Christensen <achristensen@webkit.org>
+
+ Make CompletionHandler more const correct
+ https://bugs.webkit.org/show_bug.cgi?id=186543
+
+ Reviewed by Saam Barati.
+
+ * wtf/CompletionHandler.h:
+ (WTF::CompletionHandler<Out):
+ Calling a CompletionHandler mutates it. Make the code reflect that.
+
2018-07-27 Simon Fraser <simon.fraser@apple.com>
Be more conservative with compositing layer creation when memory is low
#pragma once
-#include "Function.h"
+#include <wtf/Function.h>
namespace WTF {
template<typename> class CompletionHandler;
-// Wraps a WTF::Function to make sure it is always called once and only once.
+// Wraps a Function to make sure it is always called once and only once.
template <typename Out, typename... In>
class CompletionHandler<Out(In...)> {
public:
explicit operator bool() const { return !!m_function; }
- Out operator()(In... in) const
+ Out operator()(In... in)
{
ASSERT_WITH_MESSAGE(m_function, "Completion handler should not be called more than once");
- auto function = WTFMove(m_function);
- return function(std::forward<In>(in)...);
+ return std::exchange(m_function, nullptr)(std::forward<In>(in)...);
}
private:
- mutable WTF::Function<Out(In...)> m_function;
+ Function<Out(In...)> m_function;
};
class CompletionHandlerCallingScope {
+2018-07-27 Alex Christensen <achristensen@webkit.org>
+
+ Make CompletionHandler more const correct
+ https://bugs.webkit.org/show_bug.cgi?id=186543
+
+ Reviewed by Saam Barati.
+
+ * dom/messageports/MessagePortChannel.cpp:
+ (WebCore::MessagePortChannel::checkRemotePortForActivity):
+ * dom/messageports/MessagePortChannelProviderImpl.cpp:
+ (WebCore::MessagePortChannelProviderImpl::checkRemotePortForActivity):
+ * loader/DocumentLoader.cpp:
+ (WebCore::DocumentLoader::responseReceived):
+ * loader/FrameLoader.cpp:
+ (WebCore::FrameLoader::loadURL):
+ (WebCore::FrameLoader::loadWithDocumentLoader):
+ (WebCore::FrameLoader::loadPostRequest):
+ * platform/network/cocoa/WebCoreNSURLSession.mm:
+ (WebCore::WebCoreNSURLSessionDataTaskClient::redirectReceived):
+ * workers/service/server/RegistrationDatabase.cpp:
+ (WebCore::RegistrationDatabase::pushChanges):
+ (WebCore::RegistrationDatabase::clearAll):
+ * workers/service/server/SWServer.cpp:
+ (WebCore::SWServer::matchAll):
+ * workers/service/server/SWServer.h:
+ * workers/service/server/SWServerWorker.cpp:
+ (WebCore::SWServerWorker::matchAll):
+ * workers/service/server/SWServerWorker.h:
+
2018-07-27 Simon Fraser <simon.fraser@apple.com>
Be more conservative with compositing layer creation when memory is low
return;
}
- auto outerCallback = CompletionHandler<void(MessagePortChannelProvider::HasActivity)> { [this, protectedThis = makeRef(*this), callback = WTFMove(callback)] (MessagePortChannelProvider::HasActivity hasActivity) {
+ auto outerCallback = CompletionHandler<void(MessagePortChannelProvider::HasActivity)> { [this, protectedThis = makeRef(*this), callback = WTFMove(callback)] (MessagePortChannelProvider::HasActivity hasActivity) mutable {
if (hasActivity == MessagePortChannelProvider::HasActivity::Yes) {
callback(hasActivity);
return;
void MessagePortChannelProviderImpl::checkRemotePortForActivity(const MessagePortIdentifier& remoteTarget, CompletionHandler<void(HasActivity)>&& outerCallback)
{
- auto callback = CompletionHandler<void(HasActivity)> { [outerCallback = WTFMove(outerCallback)](HasActivity hasActivity) {
+ auto callback = CompletionHandler<void(HasActivity)> { [outerCallback = WTFMove(outerCallback)](HasActivity hasActivity) mutable {
ASSERT(isMainThread());
outerCallback(hasActivity);
} };
RefPtr<SubresourceLoader> mainResourceLoader = this->mainResourceLoader();
if (mainResourceLoader)
mainResourceLoader->markInAsyncResponsePolicyCheck();
- frameLoader()->checkContentPolicy(m_response, [this, protectedThis = makeRef(*this), mainResourceLoader = WTFMove(mainResourceLoader), completionHandler = completionHandlerCaller.release()](PolicyAction policy) {
+ frameLoader()->checkContentPolicy(m_response, [this, protectedThis = makeRef(*this), mainResourceLoader = WTFMove(mainResourceLoader), completionHandler = completionHandlerCaller.release()] (PolicyAction policy) mutable {
continueAfterContentPolicy(policy);
if (mainResourceLoader)
mainResourceLoader->didReceiveResponsePolicy();
if (!targetFrame && !frameName.isEmpty()) {
action = action.copyWithShouldOpenExternalURLsPolicy(shouldOpenExternalURLsPolicyToApply(m_frame, frameLoadRequest));
- policyChecker().checkNewWindowPolicy(WTFMove(action), WTFMove(request), WTFMove(formState), frameName, [this, allowNavigationToInvalidURL, openerPolicy, completionHandler = completionHandlerCaller.release()] (const ResourceRequest& request, WeakPtr<FormState>&& formState, const String& frameName, const NavigationAction& action, ShouldContinue shouldContinue) {
+ policyChecker().checkNewWindowPolicy(WTFMove(action), WTFMove(request), WTFMove(formState), frameName, [this, allowNavigationToInvalidURL, openerPolicy, completionHandler = completionHandlerCaller.release()] (const ResourceRequest& request, WeakPtr<FormState>&& formState, const String& frameName, const NavigationAction& action, ShouldContinue shouldContinue) mutable {
continueLoadAfterNewWindowPolicy(request, formState.get(), frameName, action, shouldContinue, allowNavigationToInvalidURL, openerPolicy);
completionHandler();
});
if (isSystemPreview)
request.setSystemPreviewRect(frameLoadRequest.systemPreviewRect());
#endif
- loadWithNavigationAction(request, action, lockHistory, newLoadType, WTFMove(formState), allowNavigationToInvalidURL, [this, isRedirect, sameURL, newLoadType, protectedFrame = makeRef(m_frame), completionHandler = completionHandlerCaller.release()] {
+ loadWithNavigationAction(request, action, lockHistory, newLoadType, WTFMove(formState), allowNavigationToInvalidURL, [this, isRedirect, sameURL, newLoadType, protectedFrame = makeRef(m_frame), completionHandler = completionHandlerCaller.release()] () mutable {
if (isRedirect) {
m_quickRedirectComing = false;
if (m_provisionalDocumentLoader)
return;
}
- policyChecker().checkNavigationPolicy(ResourceRequest(loader->request()), ResourceResponse { } /* redirectResponse */, loader, WTFMove(formState), [this, protectedFrame = makeRef(m_frame), allowNavigationToInvalidURL, completionHandler = completionHandlerCaller.release()] (const ResourceRequest& request, WeakPtr<FormState>&& formState, ShouldContinue shouldContinue) {
+ policyChecker().checkNavigationPolicy(ResourceRequest(loader->request()), ResourceResponse { } /* redirectResponse */, loader, WTFMove(formState), [this, protectedFrame = makeRef(m_frame), allowNavigationToInvalidURL, completionHandler = completionHandlerCaller.release()] (const ResourceRequest& request, WeakPtr<FormState>&& formState, ShouldContinue shouldContinue) mutable {
continueLoadAfterNavigationPolicy(request, formState.get(), shouldContinue, allowNavigationToInvalidURL);
completionHandler();
});
return;
}
- policyChecker().checkNewWindowPolicy(WTFMove(action), WTFMove(workingResourceRequest), WTFMove(formState), frameName, [this, allowNavigationToInvalidURL, openerPolicy, completionHandler = WTFMove(completionHandler)] (const ResourceRequest& request, WeakPtr<FormState>&& formState, const String& frameName, const NavigationAction& action, ShouldContinue shouldContinue) {
+ policyChecker().checkNewWindowPolicy(WTFMove(action), WTFMove(workingResourceRequest), WTFMove(formState), frameName, [this, allowNavigationToInvalidURL, openerPolicy, completionHandler = WTFMove(completionHandler)] (const ResourceRequest& request, WeakPtr<FormState>&& formState, const String& frameName, const NavigationAction& action, ShouldContinue shouldContinue) mutable {
continueLoadAfterNewWindowPolicy(request, formState.get(), frameName, action, shouldContinue, allowNavigationToInvalidURL, openerPolicy);
completionHandler();
});
// must grab this now, since this load may stop the previous load and clear this flag
bool isRedirect = m_quickRedirectComing;
- loadWithNavigationAction(workingResourceRequest, action, lockHistory, loadType, WTFMove(formState), allowNavigationToInvalidURL, [this, isRedirect, protectedFrame = makeRef(m_frame), completionHandler = WTFMove(completionHandler)] {
+ loadWithNavigationAction(workingResourceRequest, action, lockHistory, loadType, WTFMove(formState), allowNavigationToInvalidURL, [this, isRedirect, protectedFrame = makeRef(m_frame), completionHandler = WTFMove(completionHandler)] () mutable {
if (isRedirect) {
m_quickRedirectComing = false;
if (m_provisionalDocumentLoader)
if (!completionHandler)
return;
- callOnMainThread([completionHandler = WTFMove(completionHandler)] {
- completionHandler();
- });
+ callOnMainThread(WTFMove(completionHandler));
});
}
SQLiteFileSystem::deleteDatabaseFile(m_databaseFilePath);
SQLiteFileSystem::deleteEmptyDatabaseDirectory(m_databaseDirectory);
- callOnMainThread([completionHandler = WTFMove(completionHandler)] {
- completionHandler();
- });
+ callOnMainThread(WTFMove(completionHandler));
});
}
}
// https://w3c.github.io/ServiceWorker/#clients-getall
-void SWServer::matchAll(SWServerWorker& worker, const ServiceWorkerClientQueryOptions& options, const ServiceWorkerClientsMatchAllCallback& callback)
+void SWServer::matchAll(SWServerWorker& worker, const ServiceWorkerClientQueryOptions& options, ServiceWorkerClientsMatchAllCallback&& callback)
{
// FIXME: Support reserved client filtering.
// FIXME: Support WindowClient additional properties.
void didFinishInstall(const std::optional<ServiceWorkerJobDataIdentifier>&, SWServerWorker&, bool wasSuccessful);
void didFinishActivation(SWServerWorker&);
void workerContextTerminated(SWServerWorker&);
- void matchAll(SWServerWorker&, const ServiceWorkerClientQueryOptions&, const ServiceWorkerClientsMatchAllCallback&);
+ void matchAll(SWServerWorker&, const ServiceWorkerClientQueryOptions&, ServiceWorkerClientsMatchAllCallback&&);
void claim(SWServerWorker&);
WEBCORE_EXPORT void serverToContextConnectionCreated(SWServerToContextConnection&);
return m_server.serviceWorkerClientWithOriginByID(origin(), clientId);
}
-void SWServerWorker::matchAll(const ServiceWorkerClientQueryOptions& options, const ServiceWorkerClientsMatchAllCallback& callback)
+void SWServerWorker::matchAll(const ServiceWorkerClientQueryOptions& options, ServiceWorkerClientsMatchAllCallback&& callback)
{
- return m_server.matchAll(*this, options, callback);
+ return m_server.matchAll(*this, options, WTFMove(callback));
}
void SWServerWorker::claim()
void didFinishActivation();
void contextTerminated();
WEBCORE_EXPORT std::optional<ServiceWorkerClientData> findClientByIdentifier(const ServiceWorkerClientIdentifier&) const;
- void matchAll(const ServiceWorkerClientQueryOptions&, const ServiceWorkerClientsMatchAllCallback&);
+ void matchAll(const ServiceWorkerClientQueryOptions&, ServiceWorkerClientsMatchAllCallback&&);
void claim();
void setScriptResource(URL&&, ServiceWorkerContextData::ImportedScript&&);
+2018-07-27 Alex Christensen <achristensen@webkit.org>
+
+ Make CompletionHandler more const correct
+ https://bugs.webkit.org/show_bug.cgi?id=186543
+
+ Reviewed by Saam Barati.
+
+ * NetworkProcess/PingLoad.cpp:
+ (WebKit::PingLoad::willPerformHTTPRedirection):
+ * NetworkProcess/cache/CacheStorageEngine.cpp:
+ (WebKit::CacheStorage::Engine::clearAllCaches):
+ * UIProcess/Automation/SimulatedInputDispatcher.cpp:
+ (WebKit::SimulatedInputDispatcher::transitionInputSourceToState):
+ * UIProcess/Automation/WebAutomationSession.cpp:
+ (WebKit::WebAutomationSession::simulateMouseInteraction):
+ (WebKit::WebAutomationSession::simulateKeyboardInteraction):
+ * UIProcess/Cocoa/AutomationSessionClient.mm:
+ (WebKit::AutomationSessionClient::requestNewPageWithOptions):
+ (WebKit::AutomationSessionClient::requestSwitchToPage):
+ (WebKit::AutomationSessionClient::requestHideWindowOfPage):
+ (WebKit::AutomationSessionClient::requestRestoreWindowOfPage):
+ * UIProcess/Cocoa/UIDelegate.mm:
+ (WebKit::UIDelegate::ContextMenuClient::menuFromProposedMenu):
+ (WebKit::UIDelegate::UIClient::createNewPage):
+ (WebKit::UIDelegate::UIClient::runJavaScriptAlert):
+ (WebKit::UIDelegate::UIClient::runJavaScriptConfirm):
+ (WebKit::UIDelegate::UIClient::runJavaScriptPrompt):
+ (WebKit::UIDelegate::UIClient::requestStorageAccessConfirm):
+ (WebKit::UIDelegate::UIClient::decidePolicyForGeolocationPermissionRequest):
+ (WebKit::UIDelegate::UIClient::runBeforeUnloadConfirmPanel):
+ (WebKit::UIDelegate::UIClient::decidePolicyForNotificationPermissionRequest):
+ (WebKit::UIDelegate::UIClient::runOpenPanel):
+ * UIProcess/WebPageProxy.cpp:
+ (WebKit::WebPageProxy::createNewPage):
+ (WebKit::WebPageProxy::webGLPolicyForURL):
+ (WebKit::WebPageProxy::resolveWebGLPolicyForURL):
+ (WebKit::WebPageProxy::getWindowFrame):
+ * UIProcess/WebResourceLoadStatisticsStore.cpp:
+ (WebKit::WebResourceLoadStatisticsStore::hasStorageAccess):
+ (WebKit::WebResourceLoadStatisticsStore::requestStorageAccess):
+ (WebKit::WebResourceLoadStatisticsStore::scheduleClearInMemoryAndPersistent):
+ (WebKit::WebResourceLoadStatisticsStore::updateCookiePartitioning):
+
2018-07-27 Simon Fraser <simon.fraser@apple.com>
Be more conservative with compositing layer creation when memory is low
void PingLoad::willPerformHTTPRedirection(ResourceResponse&& redirectResponse, ResourceRequest&& request, RedirectCompletionHandler&& completionHandler)
{
- m_networkLoadChecker->checkRedirection(ResourceRequest { }, WTFMove(request), WTFMove(redirectResponse), nullptr, [this, completionHandler = WTFMove(completionHandler)](auto&& result) {
+ m_networkLoadChecker->checkRedirection(ResourceRequest { }, WTFMove(request), WTFMove(redirectResponse), nullptr, [this, completionHandler = WTFMove(completionHandler)] (auto&& result) mutable {
if (!result.has_value()) {
completionHandler({ });
this->didFinish(result.error());
if (WebCore::FileSystem::fileIsDirectory(filename, WebCore::FileSystem::ShouldFollowSymbolicLinks::No))
deleteDirectoryRecursively(filename);
}
- RunLoop::main().dispatch([completionHandler = WTFMove(completionHandler)] {
- completionHandler();
- });
+ RunLoop::main().dispatch(WTFMove(completionHandler));
});
}
m_ioQueue->dispatch([path = path.isolatedCopy(), completionHandler = WTFMove(completionHandler)]() mutable {
deleteDirectoryRecursively(path);
- RunLoop::main().dispatch([completionHandler = WTFMove(completionHandler)] {
- completionHandler();
- });
+ RunLoop::main().dispatch(WTFMove(completionHandler));
});
}
{
RetainPtr<_WKLinkIconParameters> parameters = adoptNS([[_WKLinkIconParameters alloc] _initWithLinkIcon:linkIcon]);
- [m_wkView performSelector:delegateSelector() withObject:parameters.get() withObject:BlockPtr<void (IconLoadCompletionHandler)>::fromCallable([completionHandler = WTFMove(completionHandler)](IconLoadCompletionHandler loadCompletionHandler) {
+ [m_wkView performSelector:delegateSelector() withObject:parameters.get() withObject:BlockPtr<void(IconLoadCompletionHandler)>::fromCallable([completionHandler = WTFMove(completionHandler)](IconLoadCompletionHandler loadCompletionHandler) mutable {
ASSERT(RunLoop::isMain());
if (loadCompletionHandler) {
completionHandler([loadCompletionHandler = BlockPtr<void (NSData *)>(loadCompletionHandler)](API::Data* data, WebKit::CallbackBase::Error error) {
SimulatedInputSourceState& a = inputSource.state;
SimulatedInputSourceState& b = newState;
- AutomationCompletionHandler eventDispatchFinished = [&inputSource, &newState, completionHandler = WTFMove(completionHandler)](std::optional<AutomationCommandError> error) {
+ AutomationCompletionHandler eventDispatchFinished = [&inputSource, &newState, completionHandler = WTFMove(completionHandler)](std::optional<AutomationCommandError> error) mutable {
if (error) {
completionHandler(error);
return;
}
// Bridge the flushed callback to our command's completion handler.
- auto mouseEventsFlushedCallback = [completionHandler = WTFMove(completionHandler)](std::optional<AutomationCommandError> error) {
+ auto mouseEventsFlushedCallback = [completionHandler = WTFMove(completionHandler)](std::optional<AutomationCommandError> error) mutable {
completionHandler(error);
};
void WebAutomationSession::simulateKeyboardInteraction(WebPageProxy& page, KeyboardInteraction interaction, WTF::Variant<VirtualKey, CharKey>&& key, CompletionHandler<void(std::optional<AutomationCommandError>)>&& completionHandler)
{
// Bridge the flushed callback to our command's completion handler.
- auto keyboardEventsFlushedCallback = [completionHandler = WTFMove(completionHandler)](std::optional<AutomationCommandError> error) {
+ auto keyboardEventsFlushedCallback = [completionHandler = WTFMove(completionHandler)](std::optional<AutomationCommandError> error) mutable {
completionHandler(error);
};
void AutomationSessionClient::requestNewPageWithOptions(WebAutomationSession& session, API::AutomationSessionBrowsingContextOptions options, CompletionHandler<void(WebKit::WebPageProxy*)>&& completionHandler)
{
if (m_delegateMethods.requestNewWebViewWithOptions) {
- [m_delegate.get() _automationSession:wrapper(session) requestNewWebViewWithOptions:toAPI(options) completionHandler:BlockPtr<void(WKWebView *)>::fromCallable([completionHandler = WTFMove(completionHandler)](WKWebView *webView) {
+ [m_delegate.get() _automationSession:wrapper(session) requestNewWebViewWithOptions:toAPI(options) completionHandler:BlockPtr<void(WKWebView *)>::fromCallable([completionHandler = WTFMove(completionHandler)](WKWebView *webView) mutable {
completionHandler(webView->_page.get());
}).get()];
} else if (m_delegateMethods.requestNewPageWithOptions) {
- [m_delegate.get() _automationSession:wrapper(session) requestNewPageWithOptions:toAPI(options) completionHandler:BlockPtr<void(WKPageRef)>::fromCallable([completionHandler = WTFMove(completionHandler)](WKPageRef page) {
+ [m_delegate.get() _automationSession:wrapper(session) requestNewPageWithOptions:toAPI(options) completionHandler:BlockPtr<void(WKPageRef)>::fromCallable([completionHandler = WTFMove(completionHandler)](WKPageRef page) mutable {
completionHandler(toImpl(page));
}).get()];
}
return;
}
- auto completionBlock = BlockPtr<void()>::fromCallable([completionHandler = WTFMove(completionHandler)]() { completionHandler(); });
+ auto completionBlock = BlockPtr<void()>::fromCallable(WTFMove(completionHandler));
if (m_delegateMethods.requestSwitchToWebView)
[m_delegate.get() _automationSession:wrapper(session) requestSwitchToWebView:fromWebPageProxy(page) completionHandler:completionBlock.get()];
else if (m_delegateMethods.requestSwitchToPage)
return;
}
- auto completionBlock = BlockPtr<void()>::fromCallable([completionHandler = WTFMove(completionHandler)]() { completionHandler(); });
+ auto completionBlock = BlockPtr<void()>::fromCallable(WTFMove(completionHandler));
if (m_delegateMethods.requestHideWindowOfWebView)
[m_delegate.get() _automationSession:wrapper(session) requestHideWindowOfWebView:fromWebPageProxy(page) completionHandler:completionBlock.get()];
else if (m_delegateMethods.requestHideWindowOfPage)
return;
}
- auto completionBlock = BlockPtr<void()>::fromCallable([completionHandler = WTFMove(completionHandler)]() { completionHandler(); });
+ auto completionBlock = BlockPtr<void()>::fromCallable(WTFMove(completionHandler));
if (m_delegateMethods.requestRestoreWindowOfWebView)
[m_delegate.get() _automationSession:wrapper(session) requestRestoreWindowOfWebView:fromWebPageProxy(page) completionHandler:completionBlock.get()];
else if (m_delegateMethods.requestRestoreWindowOfPage)
return;
}
- auto completionBlock = BlockPtr<void()>::fromCallable([completionHandler = WTFMove(completionHandler)]() { completionHandler(); });
+ auto completionBlock = BlockPtr<void()>::fromCallable(WTFMove(completionHandler));
if (m_delegateMethods.requestMaximizeWindowOfWebView)
[m_delegate.get() _automationSession:wrapper(session) requestMaximizeWindowOfWebView:fromWebPageProxy(page) completionHandler:completionBlock.get()];
else if (m_delegateMethods.requestMaximizeWindowOfPage)
RetainPtr<_WKLinkIconParameters> parameters = adoptNS([[_WKLinkIconParameters alloc] _initWithLinkIcon:linkIcon]);
- [delegate webView:m_iconLoadingDelegate.m_webView shouldLoadIconWithParameters:parameters.get() completionHandler:BlockPtr<void (IconLoadCompletionHandler loadCompletionHandler)>::fromCallable([completionHandler = WTFMove(completionHandler)] (IconLoadCompletionHandler loadCompletionHandler) {
+ [delegate webView:m_iconLoadingDelegate.m_webView shouldLoadIconWithParameters:parameters.get() completionHandler:BlockPtr<void (IconLoadCompletionHandler loadCompletionHandler)>::fromCallable([completionHandler = WTFMove(completionHandler)] (IconLoadCompletionHandler loadCompletionHandler) mutable {
ASSERT(RunLoop::isMain());
if (loadCompletionHandler) {
completionHandler([loadCompletionHandler = Block_copy(loadCompletionHandler)](API::Data* data, WebKit::CallbackBase::Error error) {
if (m_uiDelegate.m_delegateMethods.webViewGetContextMenuFromProposedMenuForElementUserInfoCompletionHandler) {
auto checker = CompletionHandlerCallChecker::create(delegate.get(), @selector(_webView:getContextMenuFromProposedMenu:forElement:userInfo:completionHandler:));
- [(id <WKUIDelegatePrivate>)delegate _webView:m_uiDelegate.m_webView getContextMenuFromProposedMenu:menu forElement:contextMenuElementInfo.get() userInfo:userInfo ? static_cast<id <NSSecureCoding>>(userInfo->wrapper()) : nil completionHandler:BlockPtr<void(NSMenu *)>::fromCallable([completionHandler = WTFMove(completionHandler), checker = WTFMove(checker)] (NSMenu *menu) {
+ [(id <WKUIDelegatePrivate>)delegate _webView:m_uiDelegate.m_webView getContextMenuFromProposedMenu:menu forElement:contextMenuElementInfo.get() userInfo:userInfo ? static_cast<id <NSSecureCoding>>(userInfo->wrapper()) : nil completionHandler:BlockPtr<void(NSMenu *)>::fromCallable([completionHandler = WTFMove(completionHandler), checker = WTFMove(checker)] (NSMenu *menu) mutable {
if (checker->completionHandlerHasBeenCalled())
return;
checker->didCallCompletionHandler();
if (m_uiDelegate.m_delegateMethods.webViewCreateWebViewWithConfigurationForNavigationActionWindowFeaturesAsync) {
auto checker = CompletionHandlerCallChecker::create(delegate.get(), @selector(_webView:createWebViewWithConfiguration:forNavigationAction:windowFeatures:completionHandler:));
- [(id <WKUIDelegatePrivate>)delegate _webView:m_uiDelegate.m_webView createWebViewWithConfiguration:configuration.get() forNavigationAction:wrapper(apiNavigationAction) windowFeatures:wrapper(apiWindowFeatures) completionHandler:BlockPtr<void (WKWebView *)>::fromCallable([completionHandler = WTFMove(completionHandler), checker = WTFMove(checker), relatedWebView = RetainPtr<WKWebView>(m_uiDelegate.m_webView)](WKWebView *webView) {
+ [(id <WKUIDelegatePrivate>)delegate _webView:m_uiDelegate.m_webView createWebViewWithConfiguration:configuration.get() forNavigationAction:wrapper(apiNavigationAction) windowFeatures:wrapper(apiWindowFeatures) completionHandler:BlockPtr<void(WKWebView *)>::fromCallable([completionHandler = WTFMove(completionHandler), checker = WTFMove(checker), relatedWebView = RetainPtr<WKWebView>(m_uiDelegate.m_webView)] (WKWebView *webView) mutable {
if (checker->completionHandlerHasBeenCalled())
return;
checker->didCallCompletionHandler();
return;
}
- RefPtr<CompletionHandlerCallChecker> checker = CompletionHandlerCallChecker::create(delegate.get(), @selector(webView:runJavaScriptAlertPanelWithMessage:initiatedByFrame:completionHandler:));
+ auto checker = CompletionHandlerCallChecker::create(delegate.get(), @selector(webView:runJavaScriptAlertPanelWithMessage:initiatedByFrame:completionHandler:));
[delegate webView:m_uiDelegate.m_webView runJavaScriptAlertPanelWithMessage:message initiatedByFrame:wrapper(API::FrameInfo::create(*webFrameProxy, securityOriginData.securityOrigin())) completionHandler:BlockPtr<void ()>::fromCallable([completionHandler = WTFMove(completionHandler), checker = WTFMove(checker)] {
if (checker->completionHandlerHasBeenCalled())
return;
return;
}
- RefPtr<CompletionHandlerCallChecker> checker = CompletionHandlerCallChecker::create(delegate.get(), @selector(webView:runJavaScriptConfirmPanelWithMessage:initiatedByFrame:completionHandler:));
- [delegate webView:m_uiDelegate.m_webView runJavaScriptConfirmPanelWithMessage:message initiatedByFrame:wrapper(API::FrameInfo::create(*webFrameProxy, securityOriginData.securityOrigin())) completionHandler:BlockPtr<void (BOOL)>::fromCallable([completionHandler = WTFMove(completionHandler), checker = WTFMove(checker)](BOOL result) {
+ auto checker = CompletionHandlerCallChecker::create(delegate.get(), @selector(webView:runJavaScriptConfirmPanelWithMessage:initiatedByFrame:completionHandler:));
+ [delegate webView:m_uiDelegate.m_webView runJavaScriptConfirmPanelWithMessage:message initiatedByFrame:wrapper(API::FrameInfo::create(*webFrameProxy, securityOriginData.securityOrigin())) completionHandler:BlockPtr<void (BOOL)>::fromCallable([completionHandler = WTFMove(completionHandler), checker = WTFMove(checker)] (BOOL result) mutable {
if (checker->completionHandlerHasBeenCalled())
return;
completionHandler(result);
}
auto checker = CompletionHandlerCallChecker::create(delegate.get(), @selector(webView:runJavaScriptTextInputPanelWithPrompt:defaultText:initiatedByFrame:completionHandler:));
- [delegate webView:m_uiDelegate.m_webView runJavaScriptTextInputPanelWithPrompt:message defaultText:defaultValue initiatedByFrame:wrapper(API::FrameInfo::create(*webFrameProxy, securityOriginData.securityOrigin())) completionHandler:BlockPtr<void (NSString *)>::fromCallable([completionHandler = WTFMove(completionHandler), checker = WTFMove(checker)](NSString *result) {
+ [delegate webView:m_uiDelegate.m_webView runJavaScriptTextInputPanelWithPrompt:message defaultText:defaultValue initiatedByFrame:wrapper(API::FrameInfo::create(*webFrameProxy, securityOriginData.securityOrigin())) completionHandler:BlockPtr<void (NSString *)>::fromCallable([completionHandler = WTFMove(completionHandler), checker = WTFMove(checker)] (NSString *result) mutable {
if (checker->completionHandlerHasBeenCalled())
return;
completionHandler(result);
}
auto checker = CompletionHandlerCallChecker::create(delegate.get(), @selector(_webView:requestStorageAccessPanelForDomain:underCurrentDomain:completionHandler:));
- [(id <WKUIDelegatePrivate>)delegate _webView:m_uiDelegate.m_webView requestStorageAccessPanelForDomain:requestingDomain underCurrentDomain:currentDomain completionHandler:BlockPtr<void(BOOL)>::fromCallable([completionHandler = WTFMove(completionHandler), checker = WTFMove(checker)](BOOL result) {
+ [(id <WKUIDelegatePrivate>)delegate _webView:m_uiDelegate.m_webView requestStorageAccessPanelForDomain:requestingDomain underCurrentDomain:currentDomain completionHandler:BlockPtr<void(BOOL)>::fromCallable([completionHandler = WTFMove(completionHandler), checker = WTFMove(checker)] (BOOL result) mutable {
if (checker->completionHandlerHasBeenCalled())
return;
completionHandler(result);
return;
auto checker = CompletionHandlerCallChecker::create(delegate.get(), @selector(_webView:requestGeolocationPermissionForFrame:decisionHandler:));
- [(id <WKUIDelegatePrivate>)delegate _webView:m_uiDelegate.m_webView requestGeolocationPermissionForFrame:wrapper(API::FrameInfo::create(frame, securityOrigin.securityOrigin())) decisionHandler:BlockPtr<void(BOOL)>::fromCallable([completionHandler = std::exchange(completionHandler, nullptr), checker = WTFMove(checker)](BOOL result) {
+ [(id <WKUIDelegatePrivate>)delegate _webView:m_uiDelegate.m_webView requestGeolocationPermissionForFrame:wrapper(API::FrameInfo::create(frame, securityOrigin.securityOrigin())) decisionHandler:BlockPtr<void(BOOL)>::fromCallable([completionHandler = std::exchange(completionHandler, nullptr), checker = WTFMove(checker)] (BOOL result) mutable {
if (checker->completionHandlerHasBeenCalled())
return;
checker->didCallCompletionHandler();
}
auto checker = CompletionHandlerCallChecker::create(delegate.get(), @selector(_webView:runBeforeUnloadConfirmPanelWithMessage:initiatedByFrame:completionHandler:));
- [(id <WKUIDelegatePrivate>)delegate _webView:m_uiDelegate.m_webView runBeforeUnloadConfirmPanelWithMessage:message initiatedByFrame:wrapper(API::FrameInfo::create(*webFrameProxy, securityOriginData.securityOrigin())) completionHandler:BlockPtr<void (BOOL)>::fromCallable([completionHandler = WTFMove(completionHandler), checker = WTFMove(checker)](BOOL result) {
+ [(id <WKUIDelegatePrivate>)delegate _webView:m_uiDelegate.m_webView runBeforeUnloadConfirmPanelWithMessage:message initiatedByFrame:wrapper(API::FrameInfo::create(*webFrameProxy, securityOriginData.securityOrigin())) completionHandler:BlockPtr<void (BOOL)>::fromCallable([completionHandler = WTFMove(completionHandler), checker = WTFMove(checker)] (BOOL result) mutable {
if (checker->completionHandlerHasBeenCalled())
return;
completionHandler(result);
return completionHandler(false);
auto checker = CompletionHandlerCallChecker::create(delegate.get(), @selector(_webView:requestNotificationPermissionForSecurityOrigin:decisionHandler:));
- [(id <WKUIDelegatePrivate>)delegate _webView:m_uiDelegate.m_webView requestNotificationPermissionForSecurityOrigin:wrapper(securityOrigin) decisionHandler:BlockPtr<void(BOOL)>::fromCallable([completionHandler = WTFMove(completionHandler), checker = WTFMove(checker)](BOOL result) {
+ [(id <WKUIDelegatePrivate>)delegate _webView:m_uiDelegate.m_webView requestNotificationPermissionForSecurityOrigin:wrapper(securityOrigin) decisionHandler:BlockPtr<void(BOOL)>::fromCallable([completionHandler = WTFMove(completionHandler), checker = WTFMove(checker)] (BOOL result) mutable {
if (checker->completionHandlerHasBeenCalled())
return;
checker->didCallCompletionHandler();
return false;
auto frame = API::FrameInfo::create(*webFrameProxy, securityOriginData.securityOrigin());
- RefPtr<WebOpenPanelResultListenerProxy> resultListener = listener;
- RefPtr<CompletionHandlerCallChecker> checker = CompletionHandlerCallChecker::create(delegate.get(), @selector(webView:runOpenPanelWithParameters:initiatedByFrame:completionHandler:));
+ auto checker = CompletionHandlerCallChecker::create(delegate.get(), @selector(webView:runOpenPanelWithParameters:initiatedByFrame:completionHandler:));
- [delegate webView:m_uiDelegate.m_webView runOpenPanelWithParameters:wrapper(*openPanelParameters) initiatedByFrame:wrapper(frame) completionHandler:[checker, resultListener](NSArray *URLs) {
+ [delegate webView:m_uiDelegate.m_webView runOpenPanelWithParameters:wrapper(*openPanelParameters) initiatedByFrame:wrapper(frame) completionHandler:BlockPtr<void(NSArray *)>::fromCallable([checker = WTFMove(checker), listener = WTFMove(listener)] (NSArray *URLs) mutable {
if (checker->completionHandlerHasBeenCalled())
return;
checker->didCallCompletionHandler();
if (!URLs) {
- resultListener->cancel();
+ listener->cancel();
return;
}
for (NSURL *url in URLs)
filenames.append(url.path);
- resultListener->chooseFiles(filenames);
- }];
+ listener->chooseFiles(filenames);
+ }).get()];
return true;
}
uint64_t callbackID = generateCallbackID();
RELEASE_LOG_IF(sessionID.isAlwaysOnLoggingAllowed(), ProcessSuspension, "%p - NetworkProcessProxy is taking a background assertion because the Network process is fetching Website data", this);
- m_pendingFetchWebsiteDataCallbacks.add(callbackID, [this, token = throttler().backgroundActivityToken(), completionHandler = WTFMove(completionHandler), sessionID](WebsiteData websiteData) {
+ m_pendingFetchWebsiteDataCallbacks.add(callbackID, [this, token = throttler().backgroundActivityToken(), completionHandler = WTFMove(completionHandler), sessionID] (WebsiteData websiteData) mutable {
#if RELEASE_LOG_DISABLED
UNUSED_PARAM(this);
UNUSED_PARAM(sessionID);
auto callbackID = generateCallbackID();
RELEASE_LOG_IF(sessionID.isAlwaysOnLoggingAllowed(), ProcessSuspension, "%p - NetworkProcessProxy is taking a background assertion because the Network process is deleting Website data", this);
- m_pendingDeleteWebsiteDataCallbacks.add(callbackID, [this, token = throttler().backgroundActivityToken(), completionHandler = WTFMove(completionHandler), sessionID] {
+ m_pendingDeleteWebsiteDataCallbacks.add(callbackID, [this, token = throttler().backgroundActivityToken(), completionHandler = WTFMove(completionHandler), sessionID] () mutable {
#if RELEASE_LOG_DISABLED
UNUSED_PARAM(this);
UNUSED_PARAM(sessionID);
uint64_t callbackID = generateCallbackID();
RELEASE_LOG_IF(sessionID.isAlwaysOnLoggingAllowed(), ProcessSuspension, "%p - NetworkProcessProxy is taking a background assertion because the Network process is deleting Website data for several origins", this);
- m_pendingDeleteWebsiteDataForOriginsCallbacks.add(callbackID, [this, token = throttler().backgroundActivityToken(), completionHandler = WTFMove(completionHandler), sessionID] {
+ m_pendingDeleteWebsiteDataForOriginsCallbacks.add(callbackID, [this, token = throttler().backgroundActivityToken(), completionHandler = WTFMove(completionHandler), sessionID] () mutable {
#if RELEASE_LOG_DISABLED
UNUSED_PARAM(this);
UNUSED_PARAM(sessionID);
}
auto callbackId = generateCallbackID();
- auto addResult = m_updatePartitionOrBlockCookiesCallbackMap.add(callbackId, [protectedThis = makeRef(*this), token = throttler().backgroundActivityToken(), callback = WTFMove(callback)] {
+ auto addResult = m_updatePartitionOrBlockCookiesCallbackMap.add(callbackId, [protectedThis = makeRef(*this), token = throttler().backgroundActivityToken(), callback = WTFMove(callback)] () mutable {
callback();
});
ASSERT_UNUSED(addResult, addResult.isNewEntry);
}
m_pendingFetchWebsiteDataRequests.clear();
- for (const auto& callback : m_pendingFetchWebsiteDataCallbacks.values())
+ for (auto&& callback : m_pendingFetchWebsiteDataCallbacks.values())
callback({ });
m_pendingFetchWebsiteDataCallbacks.clear();
m_pendingDeleteWebsiteDataRequests.clear();
- for (const auto& callback : m_pendingDeleteWebsiteDataCallbacks.values())
+ for (auto&& callback : m_pendingDeleteWebsiteDataCallbacks.values())
callback();
m_pendingDeleteWebsiteDataRequests.clear();
m_pendingDeleteWebsiteDataForHostNamesRequests.clear();
- for (const auto& callback : m_pendingDeleteWebsiteDataForHostNamesCallbacks.values())
+ for (auto&& callback : m_pendingDeleteWebsiteDataForHostNamesCallbacks.values())
callback();
m_pendingDeleteWebsiteDataForHostNamesCallbacks.clear();
RunLoop::main().dispatch([store = makeRef(m_store), subFramePrimaryDomain = subFramePrimaryDomain.isolatedCopy(), topFramePrimaryDomain = topFramePrimaryDomain.isolatedCopy(), frameID, pageID, completionHandler = WTFMove(completionHandler)]() mutable {
store->callHasStorageAccessForFrameHandler(subFramePrimaryDomain, topFramePrimaryDomain, frameID, pageID, [store = store.copyRef(), completionHandler = WTFMove(completionHandler)](bool result) mutable {
- store->statisticsQueue().dispatch([completionHandler = WTFMove(completionHandler), result] {
+ store->statisticsQueue().dispatch([completionHandler = WTFMove(completionHandler), result] () mutable {
completionHandler(result);
});
});
RunLoop::main().dispatch([subFramePrimaryDomain = subFramePrimaryDomain.isolatedCopy(), topFramePrimaryDomain = topFramePrimaryDomain.isolatedCopy(), frameID, pageID, store = makeRef(m_store), callback = WTFMove(callback)]() mutable {
store->callGrantStorageAccessHandler(subFramePrimaryDomain, topFramePrimaryDomain, frameID, pageID, [callback = WTFMove(callback), store = store.copyRef()](bool value) mutable {
- store->statisticsQueue().dispatch([callback = WTFMove(callback), value] {
+ store->statisticsQueue().dispatch([callback = WTFMove(callback), value] () mutable {
callback(value);
});
});
}
RunLoop::main().dispatch([this, store = makeRef(m_store), domainsToPartition = crossThreadCopy(domainsToPartition), domainsToBlock = crossThreadCopy(domainsToBlock), domainsToNeitherPartitionNorBlock = crossThreadCopy(domainsToNeitherPartitionNorBlock), completionHandler = WTFMove(completionHandler)] () mutable {
- store->callUpdatePrevalentDomainsToPartitionOrBlockCookiesHandler(domainsToPartition, domainsToBlock, domainsToNeitherPartitionNorBlock, ShouldClearFirst::No, [this, store = store.copyRef(), completionHandler = WTFMove(completionHandler)]() mutable {
- store->statisticsQueue().dispatch([this, completionHandler = WTFMove(completionHandler)] {
+ store->callUpdatePrevalentDomainsToPartitionOrBlockCookiesHandler(domainsToPartition, domainsToBlock, domainsToNeitherPartitionNorBlock, ShouldClearFirst::No, [this, store = store.copyRef(), completionHandler = WTFMove(completionHandler)] () mutable {
+ store->statisticsQueue().dispatch([this, completionHandler = WTFMove(completionHandler)] () mutable {
completionHandler();
#if !RELEASE_LOG_DISABLED
{
if (m_activeListener)
m_activeListener->ignore();
- m_activeListener = WebFramePolicyListenerProxy::create([this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)] (WebCore::PolicyAction action, API::WebsitePolicies* policies, ShouldProcessSwapIfPossible swap) {
+ m_activeListener = WebFramePolicyListenerProxy::create([this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)] (WebCore::PolicyAction action, API::WebsitePolicies* policies, ShouldProcessSwapIfPossible swap) mutable {
completionHandler(action, policies, swap);
m_activeListener = nullptr;
});
auto mainFrameURL = m_mainFrame->url();
- m_uiClient->createNewPage(*this, WTFMove(originatingFrameInfo), WTFMove(request), WTFMove(windowFeatures), WTFMove(navigationActionData), [this, protectedThis = makeRef(*this), mainFrameURL, request, reply = WTFMove(reply)](RefPtr<WebPageProxy> newPage) {
+ m_uiClient->createNewPage(*this, WTFMove(originatingFrameInfo), WTFMove(request), WTFMove(windowFeatures), WTFMove(navigationActionData), [this, protectedThis = makeRef(*this), mainFrameURL, request, reply = WTFMove(reply)] (RefPtr<WebPageProxy> newPage) mutable {
if (!newPage) {
reply(0, { });
return;
void WebPageProxy::webGLPolicyForURL(URL&& url, Messages::WebPageProxy::WebGLPolicyForURL::DelayedReply&& reply)
{
if (m_navigationClient) {
- m_navigationClient->webGLLoadPolicy(*this, url, [reply = WTFMove(reply)](WebGLLoadPolicy policy) {
+ m_navigationClient->webGLLoadPolicy(*this, url, [reply = WTFMove(reply)] (WebGLLoadPolicy policy) mutable {
reply(static_cast<uint32_t>(policy));
});
} else
void WebPageProxy::resolveWebGLPolicyForURL(URL&& url, Messages::WebPageProxy::ResolveWebGLPolicyForURL::DelayedReply&& reply)
{
if (m_navigationClient) {
- m_navigationClient->resolveWebGLLoadPolicy(*this, url, [reply = WTFMove(reply)](WebGLLoadPolicy policy) {
+ m_navigationClient->resolveWebGLLoadPolicy(*this, url, [reply = WTFMove(reply)] (WebGLLoadPolicy policy) mutable {
reply(static_cast<uint32_t>(policy));
});
} else
void WebPageProxy::getWindowFrame(Messages::WebPageProxy::GetWindowFrame::DelayedReply&& reply)
{
- m_uiClient->windowFrame(*this, [this, protectedThis = makeRef(*this), reply = WTFMove(reply)] (FloatRect frame) {
+ m_uiClient->windowFrame(*this, [this, protectedThis = makeRef(*this), reply = WTFMove(reply)] (FloatRect frame) mutable {
reply(m_pageClient.convertToUserSpace(frame));
});
}
auto token = throttler().backgroundActivityToken();
RELEASE_LOG_IF(sessionID.isAlwaysOnLoggingAllowed(), ProcessSuspension, "%p - WebProcessProxy is taking a background assertion because the Web process is fetching Website data", this);
- connection()->sendWithReply(Messages::WebProcess::FetchWebsiteData(sessionID, dataTypes), 0, RunLoop::main(), [this, token, completionHandler = WTFMove(completionHandler), sessionID](auto reply) {
+ connection()->sendWithReply(Messages::WebProcess::FetchWebsiteData(sessionID, dataTypes), 0, RunLoop::main(), [this, token, completionHandler = WTFMove(completionHandler), sessionID] (auto reply) mutable {
#if RELEASE_LOG_DISABLED
UNUSED_PARAM(sessionID);
UNUSED_PARAM(this);
auto token = throttler().backgroundActivityToken();
RELEASE_LOG_IF(sessionID.isAlwaysOnLoggingAllowed(), ProcessSuspension, "%p - WebProcessProxy is taking a background assertion because the Web process is deleting Website data", this);
- connection()->sendWithReply(Messages::WebProcess::DeleteWebsiteData(sessionID, dataTypes, modifiedSince), 0, RunLoop::main(), [this, token, completionHandler = WTFMove(completionHandler), sessionID](auto reply) {
+ connection()->sendWithReply(Messages::WebProcess::DeleteWebsiteData(sessionID, dataTypes, modifiedSince), 0, RunLoop::main(), [this, token, completionHandler = WTFMove(completionHandler), sessionID] (auto reply) mutable {
#if RELEASE_LOG_DISABLED
UNUSED_PARAM(this);
UNUSED_PARAM(sessionID);
auto token = throttler().backgroundActivityToken();
RELEASE_LOG_IF(sessionID.isAlwaysOnLoggingAllowed(), ProcessSuspension, "%p - WebProcessProxy is taking a background assertion because the Web process is deleting Website data for several origins", this);
- connection()->sendWithReply(Messages::WebProcess::DeleteWebsiteDataForOrigins(sessionID, dataTypes, origins), 0, RunLoop::main(), [this, token, completionHandler = WTFMove(completionHandler), sessionID](auto reply) {
+ connection()->sendWithReply(Messages::WebProcess::DeleteWebsiteDataForOrigins(sessionID, dataTypes, origins), 0, RunLoop::main(), [this, token, completionHandler = WTFMove(completionHandler), sessionID] (auto reply) mutable {
#if RELEASE_LOG_DISABLED
UNUSED_PARAM(this);
UNUSED_PARAM(sessionID);
inline void WebResourceLoadStatisticsStore::postTaskReply(WTF::Function<void()>&& reply)
{
ASSERT(!RunLoop::isMain());
- RunLoop::main().dispatch([reply = WTFMove(reply)] {
- reply();
- });
+ RunLoop::main().dispatch(WTFMove(reply));
}
void WebResourceLoadStatisticsStore::flushAndDestroyPersistentStore()
postTask([this, value, completionHandler = WTFMove(completionHandler)]() mutable {
if (m_memoryStore)
m_memoryStore->setResourceLoadStatisticsDebugMode(value);
- postTaskReply([completionHandler = WTFMove(completionHandler)] {
- completionHandler();
- });
+ postTaskReply(WTFMove(completionHandler));
});
}
postTask([this, primaryDomain = isolatedPrimaryDomain(url), completionHandler = WTFMove(completionHandler)]() mutable {
if (m_memoryStore)
m_memoryStore->setPrevalentResourceForDebugMode(primaryDomain);
- postTaskReply([completionHandler = WTFMove(completionHandler)] {
- completionHandler();
- });
+ postTaskReply(WTFMove(completionHandler));
});
}
postTask([this, subFramePrimaryDomain = isolatedPrimaryDomain(subFrameHost), topFramePrimaryDomain = isolatedPrimaryDomain(topFrameHost), frameID, pageID, completionHandler = WTFMove(completionHandler)] () mutable {
if (!m_memoryStore) {
- postTaskReply([completionHandler = WTFMove(completionHandler)] {
+ postTaskReply([completionHandler = WTFMove(completionHandler)] () mutable {
completionHandler(false);
});
return;
}
m_memoryStore->hasStorageAccess(subFramePrimaryDomain, topFramePrimaryDomain, frameID, pageID, [completionHandler = WTFMove(completionHandler)](bool hasStorageAccess) mutable {
- postTaskReply([completionHandler = WTFMove(completionHandler), hasStorageAccess] {
+ postTaskReply([completionHandler = WTFMove(completionHandler), hasStorageAccess] () mutable {
completionHandler(hasStorageAccess);
});
});
postTask([this, subFramePrimaryDomain = crossThreadCopy(subFramePrimaryDomain), topFramePrimaryDomain = crossThreadCopy(topFramePrimaryDomain), frameID, pageID, promptEnabled, completionHandler = WTFMove(completionHandler)] () mutable {
if (!m_memoryStore) {
- postTaskReply([completionHandler = WTFMove(completionHandler)] {
+ postTaskReply([completionHandler = WTFMove(completionHandler)] () mutable {
completionHandler(StorageAccessStatus::CannotRequestAccess);
});
return;
}
m_memoryStore->requestStorageAccess(WTFMove(subFramePrimaryDomain), WTFMove(topFramePrimaryDomain), frameID, pageID, promptEnabled, [completionHandler = WTFMove(completionHandler)](StorageAccessStatus status) mutable {
- postTaskReply([completionHandler = WTFMove(completionHandler), status] {
+ postTaskReply([completionHandler = WTFMove(completionHandler), status] () mutable {
completionHandler(status);
});
});
ASSERT(RunLoop::isMain());
postTask([this, subFrameHost = crossThreadCopy(subFrameHost), topFrameHost = crossThreadCopy(topFrameHost), frameID, pageID, userWasPromptedNow, completionHandler = WTFMove(completionHandler)] () mutable {
if (!m_memoryStore) {
- postTaskReply([completionHandler = WTFMove(completionHandler)] {
+ postTaskReply([completionHandler = WTFMove(completionHandler)] () mutable {
completionHandler(false);
});
return;
}
m_memoryStore->grantStorageAccess(WTFMove(subFrameHost), WTFMove(topFrameHost), frameID, pageID, userWasPromptedNow, [completionHandler = WTFMove(completionHandler)](bool wasGrantedAccess) mutable {
- postTaskReply([completionHandler = WTFMove(completionHandler), wasGrantedAccess] {
+ postTaskReply([completionHandler = WTFMove(completionHandler), wasGrantedAccess] () mutable {
completionHandler(wasGrantedAccess);
});
});
postTask([this, primaryDomain = isolatedPrimaryDomain(url), completionHandler = WTFMove(completionHandler)]() mutable {
if (m_memoryStore)
m_memoryStore->logUserInteraction(primaryDomain);
- postTaskReply([completionHandler = WTFMove(completionHandler)] {
- completionHandler();
- });
+ postTaskReply(WTFMove(completionHandler));
});
}
postTask([this, primaryDomain = isolatedPrimaryDomain(url), completionHandler = WTFMove(completionHandler)]() mutable {
if (m_memoryStore)
m_memoryStore->logNonRecentUserInteraction(primaryDomain);
- postTaskReply([completionHandler = WTFMove(completionHandler)] {
- completionHandler();
- });
+ postTaskReply(WTFMove(completionHandler));
});
}
postTask([this, primaryDomain = isolatedPrimaryDomain(url), completionHandler = WTFMove(completionHandler)]() mutable {
if (m_memoryStore)
m_memoryStore->clearUserInteraction(primaryDomain);
- postTaskReply([completionHandler = WTFMove(completionHandler)] {
- completionHandler();
- });
+ postTaskReply(WTFMove(completionHandler));
});
}
postTask([this, primaryDomain = isolatedPrimaryDomain(url), completionHandler = WTFMove(completionHandler)] () mutable {
bool hadUserInteraction = m_memoryStore ? m_memoryStore->hasHadUserInteraction(primaryDomain) : false;
- postTaskReply([hadUserInteraction, completionHandler = WTFMove(completionHandler)] {
+ postTaskReply([hadUserInteraction, completionHandler = WTFMove(completionHandler)] () mutable {
completionHandler(hadUserInteraction);
});
});
postTask([this, primaryDomain = isolatedPrimaryDomain(url), seconds, completionHandler = WTFMove(completionHandler)]() mutable {
if (m_memoryStore)
m_memoryStore->setLastSeen(primaryDomain, seconds);
- postTaskReply([completionHandler = WTFMove(completionHandler)] {
- completionHandler();
- });
+ postTaskReply(WTFMove(completionHandler));
});
}
postTask([this, primaryDomain = isolatedPrimaryDomain(url), completionHandler = WTFMove(completionHandler)]() mutable {
if (m_memoryStore)
m_memoryStore->setPrevalentResource(primaryDomain);
- postTaskReply([completionHandler = WTFMove(completionHandler)] {
- completionHandler();
- });
+ postTaskReply(WTFMove(completionHandler));
});
}
postTask([this, primaryDomain = isolatedPrimaryDomain(url), completionHandler = WTFMove(completionHandler)]() mutable {
if (m_memoryStore)
m_memoryStore->setVeryPrevalentResource(primaryDomain);
- postTaskReply([completionHandler = WTFMove(completionHandler)] {
- completionHandler();
- });
+ postTaskReply(WTFMove(completionHandler));
});
}
postTask([this, primaryDomain = isolatedPrimaryDomain(url), completionHandler = WTFMove(completionHandler)] () mutable {
bool isPrevalentResource = m_memoryStore ? m_memoryStore->isPrevalentResource(primaryDomain) : false;
- postTaskReply([isPrevalentResource, completionHandler = WTFMove(completionHandler)] {
+ postTaskReply([isPrevalentResource, completionHandler = WTFMove(completionHandler)] () mutable {
completionHandler(isPrevalentResource);
});
});
postTask([this, primaryDomain = isolatedPrimaryDomain(url), completionHandler = WTFMove(completionHandler)] () mutable {
bool isVeryPrevalentResource = m_memoryStore ? m_memoryStore->isVeryPrevalentResource(primaryDomain) : false;
- postTaskReply([isVeryPrevalentResource, completionHandler = WTFMove(completionHandler)] {
+ postTaskReply([isVeryPrevalentResource, completionHandler = WTFMove(completionHandler)] () mutable {
completionHandler(isVeryPrevalentResource);
});
});
postTask([this, subFramePrimaryDomain = isolatedPrimaryDomain(subFrame), topFramePrimaryDomain = isolatedPrimaryDomain(topFrame), completionHandler = WTFMove(completionHandler)] () mutable {
bool isRegisteredAsSubFrameUnder = m_memoryStore ? m_memoryStore->isRegisteredAsSubFrameUnder(subFramePrimaryDomain, topFramePrimaryDomain) : false;
- postTaskReply([isRegisteredAsSubFrameUnder, completionHandler = WTFMove(completionHandler)] {
+ postTaskReply([isRegisteredAsSubFrameUnder, completionHandler = WTFMove(completionHandler)] () mutable {
completionHandler(isRegisteredAsSubFrameUnder);
});
});
postTask([this, hostRedirectedFromPrimaryDomain = isolatedPrimaryDomain(hostRedirectedFrom), hostRedirectedToPrimaryDomain = isolatedPrimaryDomain(hostRedirectedTo), completionHandler = WTFMove(completionHandler)] () mutable {
bool isRegisteredAsRedirectingTo = m_memoryStore ? m_memoryStore->isRegisteredAsRedirectingTo(hostRedirectedFromPrimaryDomain, hostRedirectedToPrimaryDomain) : false;
- postTaskReply([isRegisteredAsRedirectingTo, completionHandler = WTFMove(completionHandler)] {
+ postTaskReply([isRegisteredAsRedirectingTo, completionHandler = WTFMove(completionHandler)] () mutable {
completionHandler(isRegisteredAsRedirectingTo);
});
});
postTask([this, primaryDomain = isolatedPrimaryDomain(url), completionHandler = WTFMove(completionHandler)]() mutable {
if (m_memoryStore)
m_memoryStore->clearPrevalentResource(primaryDomain);
- postTaskReply([completionHandler = WTFMove(completionHandler)] {
- completionHandler();
- });
+ postTaskReply(WTFMove(completionHandler));
});
}
postTask([this, completionHandler = WTFMove(completionHandler), primaryDomain = isolatedPrimaryDomain(url)] () mutable {
bool isGrandFathered = m_memoryStore ? m_memoryStore->isGrandfathered(primaryDomain) : false;
- postTaskReply([isGrandFathered, completionHandler = WTFMove(completionHandler)] {
+ postTaskReply([isGrandFathered, completionHandler = WTFMove(completionHandler)] () mutable {
completionHandler(isGrandFathered);
});
});
postTask([this, completionHandler = WTFMove(completionHandler)] () mutable {
if (!m_memoryStore) {
- postTaskReply([completionHandler = WTFMove(completionHandler)]() {
- completionHandler();
- });
+ postTaskReply(WTFMove(completionHandler));
return;
}
- m_memoryStore->updateCookiePartitioning([completionHandler = WTFMove(completionHandler)]() mutable {
- postTaskReply([completionHandler = WTFMove(completionHandler)]() {
- completionHandler();
- });
+ m_memoryStore->updateCookiePartitioning([completionHandler = WTFMove(completionHandler)] () mutable {
+ postTaskReply(WTFMove(completionHandler));
});
});
}
ASSERT(RunLoop::isMain());
postTask([this, domainsToPartition = crossThreadCopy(domainsToPartition), domainsToBlock = crossThreadCopy(domainsToBlock), domainsToNeitherPartitionNorBlock = crossThreadCopy(domainsToNeitherPartitionNorBlock), shouldClearFirst, completionHandler = WTFMove(completionHandler)] () mutable {
if (!m_memoryStore) {
- postTaskReply([completionHandler = WTFMove(completionHandler)]() {
- completionHandler();
- });
+ postTaskReply(WTFMove(completionHandler));
return;
}
m_memoryStore->updateCookiePartitioningForDomains(domainsToPartition, domainsToBlock, domainsToNeitherPartitionNorBlock, shouldClearFirst, [completionHandler = WTFMove(completionHandler)]() mutable {
- postTaskReply([completionHandler = WTFMove(completionHandler)]() {
- completionHandler();
- });
+ postTaskReply(WTFMove(completionHandler));
});
});
}
ASSERT(RunLoop::isMain());
postTask([this, domains = crossThreadCopy(domains), completionHandler = WTFMove(completionHandler)] () mutable {
if (!m_memoryStore) {
- postTaskReply([completionHandler = WTFMove(completionHandler)]() {
- completionHandler();
- });
+ postTaskReply(WTFMove(completionHandler));
return;
}
m_memoryStore->clearPartitioningStateForDomains(domains, [completionHandler = WTFMove(completionHandler)]() mutable {
- postTaskReply([completionHandler = WTFMove(completionHandler)]() {
- completionHandler();
- });
+ postTaskReply(WTFMove(completionHandler));
});
});
}
void WebResourceLoadStatisticsStore::scheduleClearInMemory(CompletionHandler<void()>&& completionHandler)
{
ASSERT(RunLoop::isMain());
- postTask([this, completionHandler = WTFMove(completionHandler)]() mutable {
+ postTask([this, completionHandler = WTFMove(completionHandler)] () mutable {
if (m_memoryStore)
m_memoryStore->clear();
- postTaskReply([completionHandler = WTFMove(completionHandler)] {
- completionHandler();
- });
+ postTaskReply(WTFMove(completionHandler));
});
}
m_persistentStorage->clear();
CompletionHandler<void()> callCompletionHandlerOnMainThread = [completionHandler = WTFMove(completionHandler)]() mutable {
- postTaskReply([completionHandler = WTFMove(completionHandler)] {
- completionHandler();
- });
+ postTaskReply(WTFMove(completionHandler));
};
if (shouldGrandfather == ShouldGrandfather::Yes && m_memoryStore)
if (m_memoryStore)
m_memoryStore->resetParametersToDefaultValues();
- postTaskReply([completionHandler = WTFMove(completionHandler)] {
- completionHandler();
- });
+ postTaskReply(WTFMove(completionHandler));
});
}