Changeset 246856 in webkit


Ignore:
Timestamp:
Jun 26, 2019 4:30:19 PM (5 years ago)
Author:
commit-queue@webkit.org
Message:

testRunner.setAlwaysAcceptCookies should wait for cookie accept policy to be set
https://bugs.webkit.org/show_bug.cgi?id=199230
<rdar://51757107>

Patch by Alex Christensen <achristensen@webkit.org> on 2019-06-26
Reviewed by Andy Estes.

Source/WebKit:

This patch adds an optional callback to WKCookieManagerSetHTTPCookieAcceptPolicy which is luckily only used for testing.
It also adds listener-based asynchronous versions of didReceiveSynchronousMessageFromInjectedBundle.
WebKitTestRunner uses these new abilities to wait for the cookie accept policy to be set in the network process while the web process is hung.
This removes the race condition that was causing some flakiness in tests that use testRunner.setAlwaysAcceptCookies

  • Shared/API/APIObject.h:
  • Shared/API/c/WKBase.h:
  • Sources.txt:
  • UIProcess/API/APIInjectedBundleClient.h:

(API::InjectedBundleClient::didReceiveSynchronousMessageFromInjectedBundle):

  • UIProcess/API/APIMessageListener.h: Copied from Source/WebKit/UIProcess/API/APIInjectedBundleClient.h.

(API::MessageListener::create):
(API::MessageListener::sendReply):
(API::MessageListener::MessageListener):

  • UIProcess/API/C/WKAPICast.h:
  • UIProcess/API/C/WKContextInjectedBundleClient.h:
  • UIProcess/API/C/WKCookieManager.cpp:

(WKCookieManagerSetHTTPCookieAcceptPolicy):

  • UIProcess/API/C/WKCookieManager.h:
  • UIProcess/API/C/WKMessageListener.cpp: Copied from Source/WebKit/UIProcess/API/APIInjectedBundleClient.h.

(WKMessageListenerGetTypeID):
(WKMessageListenerSendReply):

  • UIProcess/API/C/WKMessageListener.h: Copied from Source/WebKit/UIProcess/API/APIInjectedBundleClient.h.
  • UIProcess/API/C/WKPageInjectedBundleClient.h:
  • UIProcess/WebContextInjectedBundleClient.cpp:

(WebKit::WebContextInjectedBundleClient::didReceiveSynchronousMessageFromInjectedBundle):

  • UIProcess/WebContextInjectedBundleClient.h:
  • UIProcess/WebPageInjectedBundleClient.cpp:

(WebKit::WebPageInjectedBundleClient::didReceiveSynchronousMessageFromInjectedBundle):

  • UIProcess/WebPageInjectedBundleClient.h:
  • UIProcess/WebPageProxy.cpp:

(WebKit::WebPageProxy::handleSynchronousMessage):

  • UIProcess/WebPageProxy.h:

(WebKit::WebPageProxy::injectedBundleClient): Deleted.

  • UIProcess/WebProcessPool.cpp:

(WebKit::WebProcessPool::handleSynchronousMessage):

  • WebKit.xcodeproj/project.pbxproj:

Tools:

  • TestWebKitAPI/Tests/WebKit/CookieManager.cpp:

(TestWebKitAPI::didGetTestHTTPCookieAcceptPolicy):
(TestWebKitAPI::didGetUserHTTPCookieAcceptPolicy):

  • WebKitTestRunner/TestController.cpp:

(WTR::TestController::generatePageConfiguration):
(WTR::TestController::createWebViewWithOptions):
(WTR::TestController::didReceiveSynchronousMessageFromInjectedBundleWithListener):
(WTR::TestController::didReceiveSynchronousPageMessageFromInjectedBundleWithListener):
(WTR::TestController::didReceiveSynchronousMessageFromInjectedBundle):
(WTR::TestController::didReceiveSynchronousPageMessageFromInjectedBundle): Deleted.

  • WebKitTestRunner/TestController.h:
  • WebKitTestRunner/TestInvocation.cpp:

(WTR::TestInvocation::invoke):
(WTR::TestInvocation::didReceiveSynchronousMessageFromInjectedBundle):

Location:
trunk
Files:
23 edited
3 copied

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebKit/ChangeLog

    r246852 r246856  
     12019-06-26  Alex Christensen  <achristensen@webkit.org>
     2
     3        testRunner.setAlwaysAcceptCookies should wait for cookie accept policy to be set
     4        https://bugs.webkit.org/show_bug.cgi?id=199230
     5        <rdar://51757107>
     6
     7        Reviewed by Andy Estes.
     8
     9        This patch adds an optional callback to WKCookieManagerSetHTTPCookieAcceptPolicy which is luckily only used for testing.
     10        It also adds listener-based asynchronous versions of didReceiveSynchronousMessageFromInjectedBundle.
     11        WebKitTestRunner uses these new abilities to wait for the cookie accept policy to be set in the network process while the web process is hung.
     12        This removes the race condition that was causing some flakiness in tests that use testRunner.setAlwaysAcceptCookies
     13
     14        * Shared/API/APIObject.h:
     15        * Shared/API/c/WKBase.h:
     16        * Sources.txt:
     17        * UIProcess/API/APIInjectedBundleClient.h:
     18        (API::InjectedBundleClient::didReceiveSynchronousMessageFromInjectedBundle):
     19        * UIProcess/API/APIMessageListener.h: Copied from Source/WebKit/UIProcess/API/APIInjectedBundleClient.h.
     20        (API::MessageListener::create):
     21        (API::MessageListener::sendReply):
     22        (API::MessageListener::MessageListener):
     23        * UIProcess/API/C/WKAPICast.h:
     24        * UIProcess/API/C/WKContextInjectedBundleClient.h:
     25        * UIProcess/API/C/WKCookieManager.cpp:
     26        (WKCookieManagerSetHTTPCookieAcceptPolicy):
     27        * UIProcess/API/C/WKCookieManager.h:
     28        * UIProcess/API/C/WKMessageListener.cpp: Copied from Source/WebKit/UIProcess/API/APIInjectedBundleClient.h.
     29        (WKMessageListenerGetTypeID):
     30        (WKMessageListenerSendReply):
     31        * UIProcess/API/C/WKMessageListener.h: Copied from Source/WebKit/UIProcess/API/APIInjectedBundleClient.h.
     32        * UIProcess/API/C/WKPageInjectedBundleClient.h:
     33        * UIProcess/WebContextInjectedBundleClient.cpp:
     34        (WebKit::WebContextInjectedBundleClient::didReceiveSynchronousMessageFromInjectedBundle):
     35        * UIProcess/WebContextInjectedBundleClient.h:
     36        * UIProcess/WebPageInjectedBundleClient.cpp:
     37        (WebKit::WebPageInjectedBundleClient::didReceiveSynchronousMessageFromInjectedBundle):
     38        * UIProcess/WebPageInjectedBundleClient.h:
     39        * UIProcess/WebPageProxy.cpp:
     40        (WebKit::WebPageProxy::handleSynchronousMessage):
     41        * UIProcess/WebPageProxy.h:
     42        (WebKit::WebPageProxy::injectedBundleClient): Deleted.
     43        * UIProcess/WebProcessPool.cpp:
     44        (WebKit::WebProcessPool::handleSynchronousMessage):
     45        * WebKit.xcodeproj/project.pbxproj:
     46
    1472019-06-26  Wenson Hsieh  <wenson_hsieh@apple.com>
    248
  • trunk/Source/WebKit/Shared/API/APIObject.h

    r246224 r246856  
    134134        KeyValueStorageManager,
    135135        MediaCacheManager,
     136        MessageListener,
    136137        Navigation,
    137138        NavigationAction,
  • trunk/Source/WebKit/Shared/API/c/WKBase.h

    r231457 r246856  
    107107typedef const struct OpaqueWKMediaSessionFocusManager* WKMediaSessionFocusManagerRef;
    108108typedef const struct OpaqueWKMediaSessionMetadata* WKMediaSessionMetadataRef;
     109typedef const struct OpaqueWKMessageListener* WKMessageListenerRef;
    109110typedef const struct OpaqueWKNavigationAction* WKNavigationActionRef;
    110111typedef const struct OpaqueWKNavigationData* WKNavigationDataRef;
  • trunk/Source/WebKit/Sources.txt

    r246388 r246856  
    345345UIProcess/API/C/WKKeyValueStorageManager.cpp
    346346UIProcess/API/C/WKMediaSessionMetadata.cpp
     347UIProcess/API/C/WKMessageListener.cpp
    347348UIProcess/API/C/WKMockDisplay.cpp
    348349UIProcess/API/C/WKMockMediaDevice.cpp
  • trunk/Source/WebKit/UIProcess/API/APIInjectedBundleClient.h

    r218261 r246856  
    2727
    2828#include "APIObject.h"
     29#include <wtf/CompletionHandler.h>
    2930#include <wtf/Forward.h>
     31#include <wtf/RefPtr.h>
    3032
    3133namespace WebKit {
     
    4042
    4143    virtual void didReceiveMessageFromInjectedBundle(WebKit::WebProcessPool&, const WTF::String&, API::Object*) { }
    42     virtual void didReceiveSynchronousMessageFromInjectedBundle(WebKit::WebProcessPool&, const WTF::String&, API::Object*, RefPtr<API::Object>&) { }
     44    virtual void didReceiveSynchronousMessageFromInjectedBundle(WebKit::WebProcessPool&, const WTF::String&, API::Object*, CompletionHandler<void(RefPtr<API::Object>)>&& completionHandler) { completionHandler(nullptr); }
    4345    virtual RefPtr<API::Object> getInjectedBundleInitializationUserData(WebKit::WebProcessPool&) { return nullptr; }
    4446};
  • trunk/Source/WebKit/UIProcess/API/APIMessageListener.h

    r246855 r246856  
    11/*
    2  * Copyright (C) 2017 Igalia S.L.
     2 * Copyright (C) 2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
     
    2727
    2828#include "APIObject.h"
    29 #include <wtf/Forward.h>
    30 
    31 namespace WebKit {
    32 class WebProcessPool;
    33 }
     29#include <wtf/CompletionHandler.h>
    3430
    3531namespace API {
    3632
    37 class InjectedBundleClient {
     33class MessageListener : public ObjectImpl<Object::Type::MessageListener> {
     34    WTF_MAKE_NONCOPYABLE(MessageListener);
    3835public:
    39     virtual ~InjectedBundleClient() = default;
     36    static Ref<MessageListener> create(CompletionHandler<void(RefPtr<API::Object>)>&& reply)
     37    {
     38        return adoptRef(*new MessageListener(WTFMove(reply)));
     39    }
    4040
    41     virtual void didReceiveMessageFromInjectedBundle(WebKit::WebProcessPool&, const WTF::String&, API::Object*) { }
    42     virtual void didReceiveSynchronousMessageFromInjectedBundle(WebKit::WebProcessPool&, const WTF::String&, API::Object*, RefPtr<API::Object>&) { }
    43     virtual RefPtr<API::Object> getInjectedBundleInitializationUserData(WebKit::WebProcessPool&) { return nullptr; }
     41    void sendReply(RefPtr<API::Object>&& reply)
     42    {
     43        m_reply(WTFMove(reply));
     44    }
     45
     46private:
     47    MessageListener(CompletionHandler<void(RefPtr<API::Object>)>&& reply)
     48        : m_reply(WTFMove(reply)) { }
     49
     50    CompletionHandler<void(RefPtr<API::Object>)> m_reply;
    4451};
    4552
  • trunk/Source/WebKit/UIProcess/API/C/WKAPICast.h

    r246807 r246856  
    5959class FrameInfo;
    6060class HitTestResult;
     61class MessageListener;
    6162class Navigation;
    6263class NavigationAction;
     
    138139WK_ADD_API_MAPPING(WKMediaSessionFocusManagerRef, WebMediaSessionFocusManager)
    139140WK_ADD_API_MAPPING(WKMediaSessionMetadataRef, WebMediaSessionMetadata)
     141WK_ADD_API_MAPPING(WKMessageListenerRef, API::MessageListener)
    140142WK_ADD_API_MAPPING(WKNavigationActionRef, API::NavigationAction)
    141143WK_ADD_API_MAPPING(WKNavigationDataRef, API::NavigationData)
  • trunk/Source/WebKit/UIProcess/API/C/WKContextInjectedBundleClient.h

    r188279 r246856  
    3030
    3131// Injected Bundle Client
    32 typedef void (*WKContextDidReceiveMessageFromInjectedBundleCallback)(WKContextRef page, WKStringRef messageName, WKTypeRef messageBody, const void *clientInfo);
    33 typedef void (*WKContextDidReceiveSynchronousMessageFromInjectedBundleCallback)(WKContextRef page, WKStringRef messageName, WKTypeRef messageBody, WKTypeRef* returnData, const void *clientInfo);
     32typedef void (*WKContextDidReceiveMessageFromInjectedBundleCallback)(WKContextRef context, WKStringRef messageName, WKTypeRef messageBody, const void *clientInfo);
     33typedef void (*WKContextDidReceiveSynchronousMessageFromInjectedBundleCallback)(WKContextRef context, WKStringRef messageName, WKTypeRef messageBody, WKTypeRef* returnData, const void *clientInfo);
    3434typedef WKTypeRef (*WKContextGetInjectedBundleInitializationUserDataCallback)(WKContextRef context, const void *clientInfo);
     35typedef void (*WKContextDidReceiveSynchronousMessageFromInjectedBundleWithListenerCallback)(WKContextRef context, WKStringRef messageName, WKTypeRef messageBody, WKMessageListenerRef listener, const void *clientInfo);
    3536
    3637typedef struct WKContextInjectedBundleClientBase {
     
    5859} WKContextInjectedBundleClientV1;
    5960
     61typedef struct WKContextInjectedBundleClientV2 {
     62    WKContextInjectedBundleClientBase                                   base;
     63
     64    // Version 0.
     65    WKContextDidReceiveMessageFromInjectedBundleCallback                didReceiveMessageFromInjectedBundle;
     66    WKContextDidReceiveSynchronousMessageFromInjectedBundleCallback     didReceiveSynchronousMessageFromInjectedBundle;
     67
     68    // Version 1.
     69    WKContextGetInjectedBundleInitializationUserDataCallback            getInjectedBundleInitializationUserData;
     70
     71    // Version 2.
     72    WKContextDidReceiveSynchronousMessageFromInjectedBundleWithListenerCallback didReceiveSynchronousMessageFromInjectedBundleWithListener;
     73} WKContextInjectedBundleClientV2;
     74
    6075#endif // WKContextInjectedBundleClient_h
  • trunk/Source/WebKit/UIProcess/API/C/WKCookieManager.cpp

    r244924 r246856  
    6363}
    6464
    65 void WKCookieManagerSetHTTPCookieAcceptPolicy(WKCookieManagerRef cookieManager, WKHTTPCookieAcceptPolicy policy)
     65void WKCookieManagerSetHTTPCookieAcceptPolicy(WKCookieManagerRef cookieManager, WKHTTPCookieAcceptPolicy policy, void* context, WKCookieManagerSetHTTPCookieAcceptPolicyFunction callback)
    6666{
    67     toImpl(cookieManager)->setHTTPCookieAcceptPolicy(PAL::SessionID::defaultSessionID(), toHTTPCookieAcceptPolicy(policy), [](CallbackBase::Error){});
     67    toImpl(cookieManager)->setHTTPCookieAcceptPolicy(PAL::SessionID::defaultSessionID(), toHTTPCookieAcceptPolicy(policy), [context, callback](CallbackBase::Error error) {
     68        if (callback)
     69            callback(error != CallbackBase::Error::None ? toAPI(API::Error::create().ptr()) : nullptr, context);
     70    });
    6871}
    6972
  • trunk/Source/WebKit/UIProcess/API/C/WKCookieManager.h

    r234440 r246856  
    6969WK_EXPORT void WKCookieManagerDeleteAllCookiesModifiedAfterDate(WKCookieManagerRef cookieManager, double);
    7070
    71 WK_EXPORT void WKCookieManagerSetHTTPCookieAcceptPolicy(WKCookieManagerRef cookieManager, WKHTTPCookieAcceptPolicy policy);
     71typedef void (*WKCookieManagerSetHTTPCookieAcceptPolicyFunction)(WKErrorRef, void*);
     72WK_EXPORT void WKCookieManagerSetHTTPCookieAcceptPolicy(WKCookieManagerRef cookieManager, WKHTTPCookieAcceptPolicy policy, void* context, WKCookieManagerSetHTTPCookieAcceptPolicyFunction callback);
    7273typedef void (*WKCookieManagerGetHTTPCookieAcceptPolicyFunction)(WKHTTPCookieAcceptPolicy, WKErrorRef, void*);
    7374WK_EXPORT void WKCookieManagerGetHTTPCookieAcceptPolicy(WKCookieManagerRef cookieManager, void* context, WKCookieManagerGetHTTPCookieAcceptPolicyFunction callback);
  • trunk/Source/WebKit/UIProcess/API/C/WKMessageListener.cpp

    r246855 r246856  
    11/*
    2  * Copyright (C) 2017 Igalia S.L.
     2 * Copyright (C) 2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
     
    2424 */
    2525
    26 #pragma once
     26#include "config.h"
     27#include "WKMessageListener.h"
    2728
    28 #include "APIObject.h"
    29 #include <wtf/Forward.h>
     29#include "APIMessageListener.h"
    3030
    31 namespace WebKit {
    32 class WebProcessPool;
     31WKTypeID WKMessageListenerGetTypeID()
     32{
     33    return toAPI(API::MessageListener::APIType);
    3334}
    3435
    35 namespace API {
    36 
    37 class InjectedBundleClient {
    38 public:
    39     virtual ~InjectedBundleClient() = default;
    40 
    41     virtual void didReceiveMessageFromInjectedBundle(WebKit::WebProcessPool&, const WTF::String&, API::Object*) { }
    42     virtual void didReceiveSynchronousMessageFromInjectedBundle(WebKit::WebProcessPool&, const WTF::String&, API::Object*, RefPtr<API::Object>&) { }
    43     virtual RefPtr<API::Object> getInjectedBundleInitializationUserData(WebKit::WebProcessPool&) { return nullptr; }
    44 };
    45 
    46 } // namespace API
     36void WKMessageListenerSendReply(WKMessageListenerRef listenerRef, WKTypeRef value)
     37{
     38    toImpl(listenerRef)->sendReply(toImpl(value));
     39}
  • trunk/Source/WebKit/UIProcess/API/C/WKMessageListener.h

    r246855 r246856  
    11/*
    2  * Copyright (C) 2017 Igalia S.L.
     2 * Copyright (C) 2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
     
    2424 */
    2525
    26 #pragma once
     26#ifndef WKMessageListener_h
     27#define WKMessageListener_h
    2728
    28 #include "APIObject.h"
    29 #include <wtf/Forward.h>
     29#include <WebKit/WKBase.h>
    3030
    31 namespace WebKit {
    32 class WebProcessPool;
     31#ifdef __cplusplus
     32extern "C" {
     33#endif
     34
     35WK_EXPORT WKTypeID WKMessageListenerGetTypeID();
     36
     37WK_EXPORT void WKMessageListenerSendReply(WKMessageListenerRef listener, WKTypeRef reply);
     38
     39#ifdef __cplusplus
    3340}
     41#endif
    3442
    35 namespace API {
    36 
    37 class InjectedBundleClient {
    38 public:
    39     virtual ~InjectedBundleClient() = default;
    40 
    41     virtual void didReceiveMessageFromInjectedBundle(WebKit::WebProcessPool&, const WTF::String&, API::Object*) { }
    42     virtual void didReceiveSynchronousMessageFromInjectedBundle(WebKit::WebProcessPool&, const WTF::String&, API::Object*, RefPtr<API::Object>&) { }
    43     virtual RefPtr<API::Object> getInjectedBundleInitializationUserData(WebKit::WebProcessPool&) { return nullptr; }
    44 };
    45 
    46 } // namespace API
     43#endif /* WKMessageListener_h */
  • trunk/Source/WebKit/UIProcess/API/C/WKPageInjectedBundleClient.h

    r182260 r246856  
    3232typedef void (*WKPageDidReceiveSynchronousMessageFromInjectedBundleCallback)(WKPageRef page, WKStringRef messageName, WKTypeRef messageBody, WKTypeRef* returnData, const void *clientInfo);
    3333typedef WKTypeRef (*WKPageGetInjectedBundleInitializationUserDataCallback)(WKPageRef page, const void *clientInfo);
     34typedef void (*WKPageDidReceiveSynchronousMessageFromInjectedBundleWithListenerCallback)(WKPageRef page, WKStringRef messageName, WKTypeRef messageBody, WKMessageListenerRef listener, const void* clientInfo);
    3435
    3536typedef struct WKPageInjectedBundleClientBase {
     
    4647} WKPageInjectedBundleClientV0;
    4748
     49typedef struct WKPageInjectedBundleClientV1 {
     50    WKPageInjectedBundleClientBase                                   base;
     51
     52    // Version 0.
     53    WKPageDidReceiveMessageFromInjectedBundleCallback                didReceiveMessageFromInjectedBundle;
     54    WKPageDidReceiveSynchronousMessageFromInjectedBundleCallback     didReceiveSynchronousMessageFromInjectedBundle;
     55
     56    // Version 1.
     57    WKPageDidReceiveSynchronousMessageFromInjectedBundleWithListenerCallback didReceiveSynchronousMessageFromInjectedBundleWithListener;
     58} WKPageInjectedBundleClientV1;
     59
    4860#endif // WKPageInjectedBundleClient_h
  • trunk/Source/WebKit/UIProcess/WebContextInjectedBundleClient.cpp

    r218261 r246856  
    2727#include "WebContextInjectedBundleClient.h"
    2828
     29#include "APIMessageListener.h"
    2930#include "WKAPICast.h"
    3031#include "WebProcessPool.h"
     
    4647}
    4748
    48 void WebContextInjectedBundleClient::didReceiveSynchronousMessageFromInjectedBundle(WebProcessPool& processPool, const String& messageName, API::Object* messageBody, RefPtr<API::Object>& returnData)
     49void WebContextInjectedBundleClient::didReceiveSynchronousMessageFromInjectedBundle(WebProcessPool& processPool, const String& messageName, API::Object* messageBody, CompletionHandler<void(RefPtr<API::Object>)>&& completionHandler)
    4950{
    50     if (!m_client.didReceiveSynchronousMessageFromInjectedBundle)
    51         return;
     51    if (!m_client.didReceiveSynchronousMessageFromInjectedBundle && !m_client.didReceiveSynchronousMessageFromInjectedBundleWithListener)
     52        return completionHandler(nullptr);
    5253
    53     WKTypeRef returnDataRef = nullptr;
    54     m_client.didReceiveSynchronousMessageFromInjectedBundle(toAPI(&processPool), toAPI(messageName.impl()), toAPI(messageBody), &returnDataRef, m_client.base.clientInfo);
    55     returnData = adoptRef(toImpl(returnDataRef));
     54    if (m_client.didReceiveSynchronousMessageFromInjectedBundle) {
     55        WKTypeRef returnDataRef = nullptr;
     56        m_client.didReceiveSynchronousMessageFromInjectedBundle(toAPI(&processPool), toAPI(messageName.impl()), toAPI(messageBody), &returnDataRef, m_client.base.clientInfo);
     57        return completionHandler(adoptRef(toImpl(returnDataRef)));
     58    }
     59
     60    m_client.didReceiveSynchronousMessageFromInjectedBundleWithListener(toAPI(&processPool), toAPI(messageName.impl()), toAPI(messageBody), toAPI(API::MessageListener::create(WTFMove(completionHandler)).ptr()), m_client.base.clientInfo);
    5661}
    5762
  • trunk/Source/WebKit/UIProcess/WebContextInjectedBundleClient.h

    r241183 r246856  
    3535
    3636template<> struct ClientTraits<WKContextInjectedBundleClientBase> {
    37     typedef std::tuple<WKContextInjectedBundleClientV0, WKContextInjectedBundleClientV1> Versions;
     37    typedef std::tuple<WKContextInjectedBundleClientV0, WKContextInjectedBundleClientV1, WKContextInjectedBundleClientV2> Versions;
    3838};
    3939}
     
    4949
    5050    void didReceiveMessageFromInjectedBundle(WebProcessPool&, const WTF::String&, API::Object*) override;
    51     void didReceiveSynchronousMessageFromInjectedBundle(WebProcessPool&, const WTF::String&, API::Object*, RefPtr<API::Object>&) override;
     51    void didReceiveSynchronousMessageFromInjectedBundle(WebProcessPool&, const WTF::String&, API::Object*, CompletionHandler<void(RefPtr<API::Object>)>&&) override;
    5252    RefPtr<API::Object> getInjectedBundleInitializationUserData(WebProcessPool&) override;
    5353};
  • trunk/Source/WebKit/UIProcess/WebPageInjectedBundleClient.cpp

    r235265 r246856  
    2727#include "WebPageInjectedBundleClient.h"
    2828
     29#include "APIMessageListener.h"
    2930#include "WKAPICast.h"
    3031#include "WebProcessPool.h"
     
    4243}
    4344
    44 void WebPageInjectedBundleClient::didReceiveSynchronousMessageFromInjectedBundle(WebPageProxy* page, const String& messageName, API::Object* messageBody, RefPtr<API::Object>& returnData)
     45void WebPageInjectedBundleClient::didReceiveSynchronousMessageFromInjectedBundle(WebPageProxy* page, const String& messageName, API::Object* messageBody, CompletionHandler<void(RefPtr<API::Object>)>&& completionHandler)
    4546{
    46     if (!m_client.didReceiveSynchronousMessageFromInjectedBundle)
    47         return;
     47    if (!m_client.didReceiveSynchronousMessageFromInjectedBundle
     48        && !m_client.didReceiveSynchronousMessageFromInjectedBundleWithListener)
     49        return completionHandler(nullptr);
    4850
    49     WKTypeRef returnDataRef = 0;
    50     m_client.didReceiveSynchronousMessageFromInjectedBundle(toAPI(page), toAPI(messageName.impl()), toAPI(messageBody), &returnDataRef, m_client.base.clientInfo);
    51     returnData = adoptRef(toImpl(returnDataRef));
     51    if (m_client.didReceiveSynchronousMessageFromInjectedBundle) {
     52        WKTypeRef returnDataRef = nullptr;
     53        m_client.didReceiveSynchronousMessageFromInjectedBundle(toAPI(page), toAPI(messageName.impl()), toAPI(messageBody), &returnDataRef, m_client.base.clientInfo);
     54        return completionHandler(adoptRef(toImpl(returnDataRef)));
     55    }
     56
     57    m_client.didReceiveSynchronousMessageFromInjectedBundleWithListener(toAPI(page), toAPI(messageName.impl()), toAPI(messageBody), toAPI(API::MessageListener::create(WTFMove(completionHandler)).ptr()), m_client.base.clientInfo);
    5258}
    5359
  • trunk/Source/WebKit/UIProcess/WebPageInjectedBundleClient.h

    r182260 r246856  
    2424 */
    2525
    26 #ifndef WebPageInjectedBundleClient_h
    27 #define WebPageInjectedBundleClient_h
     26#pragma once
    2827
    2928#include "APIClient.h"
     
    3534
    3635template<> struct ClientTraits<WKPageInjectedBundleClientBase> {
    37     typedef std::tuple<WKPageInjectedBundleClientV0> Versions;
     36    typedef std::tuple<WKPageInjectedBundleClientV0, WKPageInjectedBundleClientV1> Versions;
    3837};
    3938}
     
    4645public:
    4746    void didReceiveMessageFromInjectedBundle(WebPageProxy*, const String&, API::Object*);
    48     void didReceiveSynchronousMessageFromInjectedBundle(WebPageProxy*, const String&, API::Object*, RefPtr<API::Object>& returnData);
     47    void didReceiveSynchronousMessageFromInjectedBundle(WebPageProxy*, const String&, API::Object*, CompletionHandler<void(RefPtr<API::Object>)>&&);
    4948};
    5049
    5150} // namespace WebKit
    52 
    53 #endif // WebPageInjectedBundleClient_h
  • trunk/Source/WebKit/UIProcess/WebPageProxy.cpp

    r246829 r246856  
    705705
    706706    RefPtr<API::Object> returnData;
    707     m_injectedBundleClient->didReceiveSynchronousMessageFromInjectedBundle(this, messageName, m_process->transformHandlesToObjects(messageBody.object()).get(), returnData);
    708     completionHandler(UserData(m_process->transformObjectsToHandles(returnData.get())));
     707    m_injectedBundleClient->didReceiveSynchronousMessageFromInjectedBundle(this, messageName, m_process->transformHandlesToObjects(messageBody.object()).get(), [completionHandler = WTFMove(completionHandler), process = m_process.copyRef()] (RefPtr<API::Object>&& returnData) mutable {
     708        completionHandler(UserData(process->transformObjectsToHandles(returnData.get())));
     709    });
    709710}
    710711
  • trunk/Source/WebKit/UIProcess/WebPageProxy.h

    r246829 r246856  
    498498    void setPolicyClient(std::unique_ptr<API::PolicyClient>&&);
    499499    void setInjectedBundleClient(const WKPageInjectedBundleClientBase*);
    500     WebPageInjectedBundleClient* injectedBundleClient() { return m_injectedBundleClient.get(); }
    501500
    502501    API::UIClient& uiClient() { return *m_uiClient; }
  • trunk/Source/WebKit/UIProcess/WebProcessPool.cpp

    r246500 r246856  
    19031903        return completionHandler({ });
    19041904
    1905     RefPtr<API::Object> returnData;
    1906     m_injectedBundleClient->didReceiveSynchronousMessageFromInjectedBundle(*this, messageName, webProcessProxy->transformHandlesToObjects(messageBody.object()).get(), returnData);
    1907     completionHandler(UserData(webProcessProxy->transformObjectsToHandles(returnData.get())));
     1905    m_injectedBundleClient->didReceiveSynchronousMessageFromInjectedBundle(*this, messageName, webProcessProxy->transformHandlesToObjects(messageBody.object()).get(), [webProcessProxy = makeRef(*webProcessProxy), completionHandler = WTFMove(completionHandler)] (RefPtr<API::Object>&& returnData) mutable {
     1906        completionHandler(UserData(webProcessProxy->transformObjectsToHandles(returnData.get())));
     1907    });
    19081908}
    19091909
  • trunk/Source/WebKit/WebKit.xcodeproj/project.pbxproj

    r246829 r246856  
    11031103                5CA26D83217AD1B800F97A35 /* WKSafeBrowsingWarning.mm in Sources */ = {isa = PBXBuildFile; fileRef = 5CA26D7F217ABBB600F97A35 /* WKSafeBrowsingWarning.mm */; };
    11041104                5CA9854A210BEB640057EB6B /* SafeBrowsingWarning.h in Headers */ = {isa = PBXBuildFile; fileRef = 5CA98549210BEB5A0057EB6B /* SafeBrowsingWarning.h */; };
     1105                5CABDC8622C40FDE001EDE8E /* WKMessageListener.h in Headers */ = {isa = PBXBuildFile; fileRef = 5CABDC8522C40FCC001EDE8E /* WKMessageListener.h */; settings = {ATTRIBUTES = (Private, ); }; };
     1106                5CABDC8722C40FED001EDE8E /* APIMessageListener.h in Headers */ = {isa = PBXBuildFile; fileRef = 5CABDC8322C40FA7001EDE8E /* APIMessageListener.h */; };
    11051107                5CADDE05215046BD0067D309 /* WKWebProcess.h in Headers */ = {isa = PBXBuildFile; fileRef = 5C74300E21500492004BFA17 /* WKWebProcess.h */; settings = {ATTRIBUTES = (Private, ); }; };
    11061108                5CAFDE452130846300B1F7E1 /* _WKInspector.h in Headers */ = {isa = PBXBuildFile; fileRef = 5CAFDE422130843500B1F7E1 /* _WKInspector.h */; settings = {ATTRIBUTES = (Private, ); }; };
     
    36053607                5CA98549210BEB5A0057EB6B /* SafeBrowsingWarning.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SafeBrowsingWarning.h; sourceTree = "<group>"; };
    36063608                5CA9854B210BEB730057EB6B /* SafeBrowsingWarningCocoa.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = SafeBrowsingWarningCocoa.mm; sourceTree = "<group>"; };
     3609                5CABDC8322C40FA7001EDE8E /* APIMessageListener.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = APIMessageListener.h; sourceTree = "<group>"; };
     3610                5CABDC8422C40FCC001EDE8E /* WKMessageListener.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WKMessageListener.cpp; sourceTree = "<group>"; };
     3611                5CABDC8522C40FCC001EDE8E /* WKMessageListener.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WKMessageListener.h; sourceTree = "<group>"; };
    36073612                5CADDE0D2151AA010067D309 /* AuthenticationChallengeDisposition.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AuthenticationChallengeDisposition.h; sourceTree = "<group>"; };
    36083613                5CAFDE422130843500B1F7E1 /* _WKInspector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = _WKInspector.h; sourceTree = "<group>"; };
     
    78447849                                7CE4D2061A46775700C7F152 /* APILegacyContextHistoryClient.h */,
    78457850                                1A2464F21891E45100234C5B /* APILoaderClient.h */,
     7851                                5CABDC8322C40FA7001EDE8E /* APIMessageListener.h */,
    78467852                                7CD3A4801A5D02FA009623B8 /* APINavigation.cpp */,
    78477853                                7CD3A4811A5D02FA009623B8 /* APINavigation.h */,
     
    79477953                                C9CD43991B4B024200239E33 /* WKMediaSessionMetadata.cpp */,
    79487954                                C9CD439A1B4B024200239E33 /* WKMediaSessionMetadata.h */,
     7955                                5CABDC8422C40FCC001EDE8E /* WKMessageListener.cpp */,
     7956                                5CABDC8522C40FCC001EDE8E /* WKMessageListener.h */,
    79497957                                C11E1693212B87C500985FF6 /* WKMockDisplay.cpp */,
    79507958                                C11E1692212B87C500985FF6 /* WKMockDisplay.h */,
     
    92519259                                7CE4D2071A46776100C7F152 /* APILegacyContextHistoryClient.h in Headers */,
    92529260                                1A2464F31891E45100234C5B /* APILoaderClient.h in Headers */,
     9261                                5CABDC8722C40FED001EDE8E /* APIMessageListener.h in Headers */,
    92539262                                7CD3A4831A5D02FA009623B8 /* APINavigation.h in Headers */,
    92549263                                2DF9EEEC1A7836EE00B6CFBE /* APINavigationAction.h in Headers */,
     
    1010010109                                C9CD439D1B4B024F00239E33 /* WKMediaSessionMetadata.h in Headers */,
    1010110110                                1AB40EE61BF677E300BA81BE /* WKMenuItemIdentifiersPrivate.h in Headers */,
     10111                                5CABDC8622C40FDE001EDE8E /* WKMessageListener.h in Headers */,
    1010210112                                C11E1694212B87C500985FF6 /* WKMockDisplay.h in Headers */,
    1010310113                                411A8DDB20DDD1AC0060D34F /* WKMockMediaDevice.h in Headers */,
  • trunk/Tools/ChangeLog

    r246848 r246856  
     12019-06-26  Alex Christensen  <achristensen@webkit.org>
     2
     3        testRunner.setAlwaysAcceptCookies should wait for cookie accept policy to be set
     4        https://bugs.webkit.org/show_bug.cgi?id=199230
     5        <rdar://51757107>
     6
     7        Reviewed by Andy Estes.
     8
     9        * TestWebKitAPI/Tests/WebKit/CookieManager.cpp:
     10        (TestWebKitAPI::didGetTestHTTPCookieAcceptPolicy):
     11        (TestWebKitAPI::didGetUserHTTPCookieAcceptPolicy):
     12        * WebKitTestRunner/TestController.cpp:
     13        (WTR::TestController::generatePageConfiguration):
     14        (WTR::TestController::createWebViewWithOptions):
     15        (WTR::TestController::didReceiveSynchronousMessageFromInjectedBundleWithListener):
     16        (WTR::TestController::didReceiveSynchronousPageMessageFromInjectedBundleWithListener):
     17        (WTR::TestController::didReceiveSynchronousMessageFromInjectedBundle):
     18        (WTR::TestController::didReceiveSynchronousPageMessageFromInjectedBundle): Deleted.
     19        * WebKitTestRunner/TestController.h:
     20        * WebKitTestRunner/TestInvocation.cpp:
     21        (WTR::TestInvocation::invoke):
     22        (WTR::TestInvocation::didReceiveSynchronousMessageFromInjectedBundle):
     23
    1242019-06-26  Ross Kirsling  <ross.kirsling@sony.com>
    225
  • trunk/Tools/TestWebKitAPI/Tests/WebKit/CookieManager.cpp

    r239631 r246856  
    4747
    4848    WKCookieManagerRef cookieManager = WKContextGetCookieManager(wkContext.get());
    49     WKCookieManagerSetHTTPCookieAcceptPolicy(cookieManager, userPolicy);
     49    WKCookieManagerSetHTTPCookieAcceptPolicy(cookieManager, userPolicy, nullptr, nullptr);
    5050
    5151    testDone = true;
     
    6161    testPolicy = (userPolicy + 1) % 3;
    6262    WKCookieManagerRef cookieManager = WKContextGetCookieManager(wkContext.get());
    63     WKCookieManagerSetHTTPCookieAcceptPolicy(cookieManager, testPolicy);
     63    WKCookieManagerSetHTTPCookieAcceptPolicy(cookieManager, testPolicy, nullptr, nullptr);
    6464    WKCookieManagerGetHTTPCookieAcceptPolicy(cookieManager, reinterpret_cast<void*>(0x1234578), didGetTestHTTPCookieAcceptPolicy);
    6565}
  • trunk/Tools/WebKitTestRunner/TestController.cpp

    r246118 r246856  
    4444#include <WebKit/WKFrameInfoRef.h>
    4545#include <WebKit/WKIconDatabase.h>
     46#include <WebKit/WKMessageListener.h>
    4647#include <WebKit/WKMockDisplay.h>
    4748#include <WebKit/WKMockMediaDevice.h>
     
    7475#include <string>
    7576#include <wtf/AutodrainedPool.h>
     77#include <wtf/CompletionHandler.h>
    7678#include <wtf/CryptographicallyRandomNumber.h>
    7779#include <wtf/MainThread.h>
     
    539541    }
    540542
    541     WKContextInjectedBundleClientV1 injectedBundleClient = {
    542         { 1, this },
     543    WKContextInjectedBundleClientV2 injectedBundleClient = {
     544        { 2, this },
    543545        didReceiveMessageFromInjectedBundle,
    544         didReceiveSynchronousMessageFromInjectedBundle,
     546        nullptr,
    545547        getInjectedBundleInitializationUserData,
     548        didReceiveSynchronousMessageFromInjectedBundleWithListener,
    546549    };
    547550    WKContextSetInjectedBundleClient(m_context.get(), &injectedBundleClient.base);
     
    718721   
    719722    // this should just be done on the page?
    720     WKPageInjectedBundleClientV0 injectedBundleClient = {
    721         { 0, this },
     723    WKPageInjectedBundleClientV1 injectedBundleClient = {
     724        { 1, this },
    722725        didReceivePageMessageFromInjectedBundle,
    723         didReceiveSynchronousPageMessageFromInjectedBundle
     726        nullptr,
     727        didReceiveSynchronousPageMessageFromInjectedBundleWithListener,
    724728    };
    725729    WKPageSetPageInjectedBundleClient(m_mainWebView->page(), &injectedBundleClient.base);
     
    17301734}
    17311735
    1732 void TestController::didReceiveSynchronousMessageFromInjectedBundle(WKContextRef context, WKStringRef messageName, WKTypeRef messageBody, WKTypeRef* returnData, const void* clientInfo)
    1733 {
    1734     *returnData = static_cast<TestController*>(const_cast<void*>(clientInfo))->didReceiveSynchronousMessageFromInjectedBundle(messageName, messageBody).leakRef();
     1736void TestController::didReceiveSynchronousMessageFromInjectedBundleWithListener(WKContextRef context, WKStringRef messageName, WKTypeRef messageBody, WKMessageListenerRef listener, const void* clientInfo)
     1737{
     1738    static_cast<TestController*>(const_cast<void*>(clientInfo))->didReceiveSynchronousMessageFromInjectedBundle(messageName, messageBody, listener);
    17351739}
    17361740
     
    17471751}
    17481752
    1749 void TestController::didReceiveSynchronousPageMessageFromInjectedBundle(WKPageRef page, WKStringRef messageName, WKTypeRef messageBody, WKTypeRef* returnData, const void* clientInfo)
    1750 {
    1751     *returnData = static_cast<TestController*>(const_cast<void*>(clientInfo))->didReceiveSynchronousMessageFromInjectedBundle(messageName, messageBody).leakRef();
     1753void TestController::didReceiveSynchronousPageMessageFromInjectedBundleWithListener(WKPageRef page, WKStringRef messageName, WKTypeRef messageBody, WKMessageListenerRef listener, const void* clientInfo)
     1754{
     1755    static_cast<TestController*>(const_cast<void*>(clientInfo))->didReceiveSynchronousMessageFromInjectedBundle(messageName, messageBody, listener);
    17521756}
    17531757
     
    18861890}
    18871891
    1888 WKRetainPtr<WKTypeRef> TestController::didReceiveSynchronousMessageFromInjectedBundle(WKStringRef messageName, WKTypeRef messageBody)
    1889 {
     1892void TestController::didReceiveSynchronousMessageFromInjectedBundle(WKStringRef messageName, WKTypeRef messageBody, WKMessageListenerRef listener)
     1893{
     1894    auto completionHandler = [listener = retainWK(listener)] (WKTypeRef reply) {
     1895        WKMessageListenerSendReply(listener.get(), reply);
     1896    };
     1897
    18901898    if (WKStringIsEqualToUTF8CString(messageName, "EventSender")) {
    18911899        if (m_state != RunningTest)
    1892             return nullptr;
     1900            return completionHandler(nullptr);
    18931901
    18941902        ASSERT(WKGetTypeID(messageBody) == WKDictionaryGetTypeID());
     
    19011909            didReceiveKeyDownMessageFromInjectedBundle(messageBodyDictionary, true);
    19021910
    1903             return 0;
     1911            return completionHandler(nullptr);
    19041912        }
    19051913
     
    19161924            else
    19171925                m_eventSenderProxy->mouseUp(button, modifiers);
    1918             return 0;
     1926            return completionHandler(nullptr);
    19191927        }
    19201928
     
    19281936            // Forward to WebProcess
    19291937            m_eventSenderProxy->mouseMoveTo(x, y);
    1930             return 0;
     1938            return completionHandler(nullptr);
    19311939        }
    19321940
     
    19341942        if (WKStringIsEqualToUTF8CString(subMessageName, "MouseForceClick")) {
    19351943            m_eventSenderProxy->mouseForceClick();
    1936             return 0;
     1944            return completionHandler(nullptr);
    19371945        }
    19381946
    19391947        if (WKStringIsEqualToUTF8CString(subMessageName, "StartAndCancelMouseForceClick")) {
    19401948            m_eventSenderProxy->startAndCancelMouseForceClick();
    1941             return 0;
     1949            return completionHandler(nullptr);
    19421950        }
    19431951
    19441952        if (WKStringIsEqualToUTF8CString(subMessageName, "MouseForceDown")) {
    19451953            m_eventSenderProxy->mouseForceDown();
    1946             return 0;
     1954            return completionHandler(nullptr);
    19471955        }
    19481956
    19491957        if (WKStringIsEqualToUTF8CString(subMessageName, "MouseForceUp")) {
    19501958            m_eventSenderProxy->mouseForceUp();
    1951             return 0;
     1959            return completionHandler(nullptr);
    19521960        }
    19531961
     
    19571965
    19581966            m_eventSenderProxy->mouseForceChanged(force);
    1959             return 0;
     1967            return completionHandler(nullptr);
    19601968        }
    19611969#endif // PLATFORM(MAC)
     
    19731981            // Forward to WebProcess
    19741982            m_eventSenderProxy->continuousMouseScrollBy(x, y, paged);
    1975             return 0;
     1983            return completionHandler(nullptr);
    19761984        }
    19771985
     
    19811989
    19821990            m_eventSenderProxy->leapForward(time);
    1983             return 0;
     1991            return completionHandler(nullptr);
    19841992        }
    19851993
     
    19932001
    19942002            m_eventSenderProxy->addTouchPoint(x, y);
    1995             return 0;
     2003            return completionHandler(nullptr);
    19962004        }
    19972005
     
    20072015
    20082016            m_eventSenderProxy->updateTouchPoint(index, x, y);
    2009             return 0;
     2017            return completionHandler(nullptr);
    20102018        }
    20112019
     
    20182026
    20192027            m_eventSenderProxy->setTouchModifier(modifier, enable);
    2020             return 0;
     2028            return completionHandler(nullptr);
    20212029        }
    20222030
     
    20292037
    20302038            m_eventSenderProxy->setTouchPointRadius(x, y);
    2031             return 0;
     2039            return completionHandler(nullptr);
    20322040        }
    20332041
    20342042        if (WKStringIsEqualToUTF8CString(subMessageName, "TouchStart")) {
    20352043            m_eventSenderProxy->touchStart();
    2036             return 0;
     2044            return completionHandler(nullptr);
    20372045        }
    20382046
    20392047        if (WKStringIsEqualToUTF8CString(subMessageName, "TouchMove")) {
    20402048            m_eventSenderProxy->touchMove();
    2041             return 0;
     2049            return completionHandler(nullptr);
    20422050        }
    20432051
    20442052        if (WKStringIsEqualToUTF8CString(subMessageName, "TouchEnd")) {
    20452053            m_eventSenderProxy->touchEnd();
    2046             return 0;
     2054            return completionHandler(nullptr);
    20472055        }
    20482056
    20492057        if (WKStringIsEqualToUTF8CString(subMessageName, "TouchCancel")) {
    20502058            m_eventSenderProxy->touchCancel();
    2051             return 0;
     2059            return completionHandler(nullptr);
    20522060        }
    20532061
    20542062        if (WKStringIsEqualToUTF8CString(subMessageName, "ClearTouchPoints")) {
    20552063            m_eventSenderProxy->clearTouchPoints();
    2056             return 0;
     2064            return completionHandler(nullptr);
    20572065        }
    20582066
     
    20612069            int index = static_cast<int>(WKUInt64GetValue(static_cast<WKUInt64Ref>(WKDictionaryGetItemForKey(messageBodyDictionary, indexKey.get()))));
    20622070            m_eventSenderProxy->releaseTouchPoint(index);
    2063             return 0;
     2071            return completionHandler(nullptr);
    20642072        }
    20652073
     
    20682076            int index = static_cast<int>(WKUInt64GetValue(static_cast<WKUInt64Ref>(WKDictionaryGetItemForKey(messageBodyDictionary, indexKey.get()))));
    20692077            m_eventSenderProxy->cancelTouchPoint(index);
    2070             return 0;
     2078            return completionHandler(nullptr);
    20712079        }
    20722080#endif
    20732081        ASSERT_NOT_REACHED();
    20742082    }
    2075     return m_currentInvocation->didReceiveSynchronousMessageFromInjectedBundle(messageName, messageBody);
     2083
     2084    auto setHTTPCookieAcceptPolicy = [&] (WKHTTPCookieAcceptPolicy policy, CompletionHandler<void(WKTypeRef)>&& completionHandler) {
     2085        auto context = new CompletionHandler<void(WKTypeRef)>(WTFMove(completionHandler));
     2086        WKCookieManagerSetHTTPCookieAcceptPolicy(WKContextGetCookieManager(this->context()), policy, context, [] (WKErrorRef error, void* context) {
     2087            auto completionHandlerPointer = static_cast<CompletionHandler<void(WKTypeRef)>*>(context);
     2088            (*completionHandlerPointer)(nullptr);
     2089            delete completionHandlerPointer;
     2090        });
     2091    };
     2092
     2093    if (WKStringIsEqualToUTF8CString(messageName, "SetAlwaysAcceptCookies")) {
     2094        WKBooleanRef accept = static_cast<WKBooleanRef>(messageBody);
     2095        WKHTTPCookieAcceptPolicy policy = WKBooleanGetValue(accept) ? kWKHTTPCookieAcceptPolicyAlways : kWKHTTPCookieAcceptPolicyOnlyFromMainDocumentDomain;
     2096        return setHTTPCookieAcceptPolicy(policy, WTFMove(completionHandler));
     2097    }
     2098
     2099    if (WKStringIsEqualToUTF8CString(messageName, "SetOnlyAcceptFirstPartyCookies")) {
     2100        WKBooleanRef accept = static_cast<WKBooleanRef>(messageBody);
     2101        WKHTTPCookieAcceptPolicy policy = WKBooleanGetValue(accept) ? kWKHTTPCookieAcceptPolicyExclusivelyFromMainDocumentDomain : kWKHTTPCookieAcceptPolicyOnlyFromMainDocumentDomain;
     2102        return setHTTPCookieAcceptPolicy(policy, WTFMove(completionHandler));
     2103    }
     2104
     2105    completionHandler(m_currentInvocation->didReceiveSynchronousMessageFromInjectedBundle(messageName, messageBody).get());
    20762106}
    20772107
  • trunk/Tools/WebKitTestRunner/TestController.h

    r246118 r246856  
    378378    // WKContextInjectedBundleClient
    379379    static void didReceiveMessageFromInjectedBundle(WKContextRef, WKStringRef messageName, WKTypeRef messageBody, const void*);
    380     static void didReceiveSynchronousMessageFromInjectedBundle(WKContextRef, WKStringRef messageName, WKTypeRef messageBody, WKTypeRef* returnData, const void*);
     380    static void didReceiveSynchronousMessageFromInjectedBundleWithListener(WKContextRef, WKStringRef messageName, WKTypeRef messageBody, WKMessageListenerRef, const void*);
    381381    static WKTypeRef getInjectedBundleInitializationUserData(WKContextRef, const void *clientInfo);
    382382
    383383    // WKPageInjectedBundleClient
    384384    static void didReceivePageMessageFromInjectedBundle(WKPageRef, WKStringRef messageName, WKTypeRef messageBody, const void*);
    385     static void didReceiveSynchronousPageMessageFromInjectedBundle(WKPageRef, WKStringRef messageName, WKTypeRef messageBody, WKTypeRef* returnData, const void*);
     385    static void didReceiveSynchronousPageMessageFromInjectedBundleWithListener(WKPageRef, WKStringRef messageName, WKTypeRef messageBody, WKMessageListenerRef, const void*);
    386386    void didReceiveMessageFromInjectedBundle(WKStringRef messageName, WKTypeRef messageBody);
    387     WKRetainPtr<WKTypeRef> didReceiveSynchronousMessageFromInjectedBundle(WKStringRef messageName, WKTypeRef messageBody);
     387    void didReceiveSynchronousMessageFromInjectedBundle(WKStringRef messageName, WKTypeRef messageBody, WKMessageListenerRef);
    388388    WKRetainPtr<WKTypeRef> getInjectedBundleInitializationUserData();
    389389
  • trunk/Tools/WebKitTestRunner/TestInvocation.cpp

    r245280 r246856  
    165165    TestController::singleton().setShouldLogHistoryClientCallbacks(shouldLogHistoryClientCallbacks());
    166166
    167     WKCookieManagerSetHTTPCookieAcceptPolicy(WKContextGetCookieManager(TestController::singleton().context()), kWKHTTPCookieAcceptPolicyOnlyFromMainDocumentDomain);
     167    WKCookieManagerSetHTTPCookieAcceptPolicy(WKContextGetCookieManager(TestController::singleton().context()), kWKHTTPCookieAcceptPolicyOnlyFromMainDocumentDomain, nullptr, nullptr);
    168168
    169169    // FIXME: We should clear out visited links here.
     
    905905    }
    906906
    907     if (WKStringIsEqualToUTF8CString(messageName, "SetAlwaysAcceptCookies")) {
    908         WKBooleanRef accept = static_cast<WKBooleanRef>(messageBody);
    909         WKHTTPCookieAcceptPolicy policy = WKBooleanGetValue(accept) ? kWKHTTPCookieAcceptPolicyAlways : kWKHTTPCookieAcceptPolicyOnlyFromMainDocumentDomain;
    910         // FIXME: This updates the policy in WebProcess and in NetworkProcess asynchronously, which might break some tests' expectations.
    911         WKCookieManagerSetHTTPCookieAcceptPolicy(WKContextGetCookieManager(TestController::singleton().context()), policy);
    912         return nullptr;
    913     }
    914 
    915     if (WKStringIsEqualToUTF8CString(messageName, "SetOnlyAcceptFirstPartyCookies")) {
    916         WKBooleanRef accept = static_cast<WKBooleanRef>(messageBody);
    917         WKHTTPCookieAcceptPolicy policy = WKBooleanGetValue(accept) ? kWKHTTPCookieAcceptPolicyExclusivelyFromMainDocumentDomain : kWKHTTPCookieAcceptPolicyOnlyFromMainDocumentDomain;
    918         // FIXME: This updates the policy in WebProcess and in NetworkProcess asynchronously, which might break some tests' expectations.
    919         WKCookieManagerSetHTTPCookieAcceptPolicy(WKContextGetCookieManager(TestController::singleton().context()), policy);
    920         return nullptr;
    921     }
    922    
    923907    if (WKStringIsEqualToUTF8CString(messageName, "SetCustomUserAgent")) {
    924908        WKStringRef userAgent = static_cast<WKStringRef>(messageBody);
Note: See TracChangeset for help on using the changeset viewer.