Attachment 338905 Details for Bug 181151 – Patch

[patch] Patch

bug-181151-20180426204010.patch (text/plain), 17.99 KB, created by Yusuke Suzuki on 2018-04-26 12:40:12 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Yusuke Suzuki

Created: 2018-04-26 12:40:12 PDT

Size: 17.99 KB

patch

obsolete

>Subversion Revision: 231043
>diff --git a/Source/WTF/ChangeLog b/Source/WTF/ChangeLog
>index 1d2d20d2b0883ab457bf17d10a3b1c08761fd1fe..d66fc8a799e9635a27e8dbf96532b40a335dd3d5 100644
>--- a/Source/WTF/ChangeLog
>+++ b/Source/WTF/ChangeLog
>@@ -1,3 +1,37 @@
>+2018-04-26  Yusuke Suzuki  <utatane.tea@gmail.com>
>+
>+        [WTF] Align assumption in RunLoopWin to the other platform's RunLoop
>+        https://bugs.webkit.org/show_bug.cgi?id=181151
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        This patch fixes RunLoop in Windows to align it to the implementations in the other platforms
>+        to use RunLoop more aggressively.
>+
>+        * wtf/RunLoop.h:
>+        (WTF::RunLoop::Timer::Timer):
>+        * wtf/win/RunLoopWin.cpp:
>+        (WTF::RunLoop::wndProc):
>+        (WTF::RunLoop::iterate):
>+        (WTF::RunLoop::stop):
>+        PostQuitMessage is only available in the RunLoop's thread. We should post a message and call
>+        it inside this task.
>+
>+        (WTF::RunLoop::registerRunLoopMessageWindowClass):
>+        Use call_once to register window class only once.
>+
>+        (WTF::RunLoop::~RunLoop):
>+        When the RunLoop's thread is freed, its associated window is freed. We do not need to do here.
>+
>+        (WTF::RunLoop::TimerBase::timerFired):
>+        (WTF::RunLoop::TimerBase::TimerBase):
>+        (WTF::RunLoop::TimerBase::start):
>+        (WTF::RunLoop::TimerBase::stop):
>+        (WTF::RunLoop::TimerBase::isActive const):
>+        (WTF::RunLoop::TimerBase::secondsUntilFire const):
>+        (WTF::generateTimerID): Deleted.
>+        We can use TimerBase's pointer as ID since it is uintptr_t.
>+
> 2018-04-25  Mark Lam  <mark.lam@apple.com>
> 
>         Gardening: Speculative build fix for Windows 32-bit to compensate for MSVC's lack of smarts.
>diff --git a/Source/WTF/wtf/RunLoop.h b/Source/WTF/wtf/RunLoop.h
>index f4fd3bf0432e6b2d1b30c7c28d993396cfe1aa43..0a0d27f150654e35e1c68bba929cad1c1d60e4cd 100644
>--- a/Source/WTF/wtf/RunLoop.h
>+++ b/Source/WTF/wtf/RunLoop.h
>@@ -69,7 +69,7 @@ class RunLoop : public FunctionDispatcher {
>     WTF_EXPORT_PRIVATE GMainContext* mainContext() const { return m_mainContext.get(); }
> #endif
> 
>-#if USE(GENERIC_EVENT_LOOP)
>+#if USE(GENERIC_EVENT_LOOP) || USE(WINDOWS_EVENT_LOOP)
>     // Run the single iteration of the RunLoop. It consumes the pending tasks and expired timers, but it won't be blocked.
>     WTF_EXPORT_PRIVATE static void iterate();
> #endif
>@@ -110,11 +110,11 @@ class RunLoop : public FunctionDispatcher {
> 
> #if USE(WINDOWS_EVENT_LOOP)
>         bool isActive(const AbstractLocker&) const;
>-        static void timerFired(RunLoop*, uint64_t ID);
>-        uint64_t m_ID;
>+        void timerFired();
>         MonotonicTime m_nextFireDate;
>         Seconds m_interval;
>-        bool m_isRepeating;
>+        bool m_isRepeating { false };
>+        bool m_isActive { false };
> #elif USE(COCOA_EVENT_LOOP)
>         static void timerFired(CFRunLoopTimerRef, void*);
>         RetainPtr<CFRunLoopTimerRef> m_timer;
>@@ -139,16 +139,18 @@ class RunLoop : public FunctionDispatcher {
> 
>         Timer(RunLoop& runLoop, TimerFiredClass* o, TimerFiredFunction f)
>             : TimerBase(runLoop)
>-            , m_object(o)
>             , m_function(f)
>+            , m_object(o)
>         {
>         }
> 
>     private:
>         void fired() override { (m_object->*m_function)(); }
> 
>-        TimerFiredClass* m_object;
>+        // This order should be maintained due to MSVC bug.
>+        // http://computer-programming-forum.com/7-vc.net/6fbc30265f860ad1.htm
>         TimerFiredFunction m_function;
>+        TimerFiredClass* m_object;
>     };
> 
>     class Holder;
>@@ -162,14 +164,11 @@ class RunLoop : public FunctionDispatcher {
>     Deque<Function<void()>> m_functionQueue;
> 
> #if USE(WINDOWS_EVENT_LOOP)
>-    static bool registerRunLoopMessageWindowClass();
>+    static void registerRunLoopMessageWindowClass();
>     static LRESULT CALLBACK RunLoopWndProc(HWND, UINT, WPARAM, LPARAM);
>     LRESULT wndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
>     HWND m_runLoopMessageWindow;
>-
>-    typedef HashMap<uint64_t, TimerBase*> TimerMap;
>-    Lock m_activeTimersLock;
>-    TimerMap m_activeTimers;
>+    Lock m_loopLock;
> #elif USE(COCOA_EVENT_LOOP)
>     static void performWork(void*);
>     RetainPtr<CFRunLoopRef> m_runLoop;
>diff --git a/Source/WTF/wtf/win/RunLoopWin.cpp b/Source/WTF/wtf/win/RunLoopWin.cpp
>index 368132abd27b739135c77413a635e27e7190db60..71f2f2f924fa21275eb27f42d2085336739cf27b 100644
>--- a/Source/WTF/wtf/win/RunLoopWin.cpp
>+++ b/Source/WTF/wtf/win/RunLoopWin.cpp
>@@ -56,7 +56,7 @@ LRESULT RunLoop::wndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
>         performWork();
>         return 0;
>     case WM_TIMER:
>-        RunLoop::TimerBase::timerFired(this, wParam);
>+        bitwise_cast<RunLoop::TimerBase*>(wParam)->timerFired();
>         return 0;
>     }
> 
>@@ -74,21 +74,35 @@ void RunLoop::run()
>     }
> }
> 
>-void RunLoop::stop()
>+void RunLoop::iterate()
> {
>-    ::PostQuitMessage(0);
>+    MSG message;
>+    while (BOOL result = ::PeekMessage(&message, 0, 0, 0, PM_REMOVE)) {
>+        ::TranslateMessage(&message);
>+        ::DispatchMessage(&message);
>+    }
> }
> 
>-bool RunLoop::registerRunLoopMessageWindowClass()
>+void RunLoop::stop()
> {
>-    // FIXME: This really only needs to be called once.
>-
>-    WNDCLASS windowClass = { 0 };
>-    windowClass.lpfnWndProc     = RunLoop::RunLoopWndProc;
>-    windowClass.cbWndExtra      = sizeof(RunLoop*);
>-    windowClass.lpszClassName   = kRunLoopMessageWindowClassName;
>+    // RunLoop::stop() can be called from threads unrelated to this RunLoop.
>+    // We should post a message that call PostQuitMessage in RunLoop's thread.
>+    dispatch([] {
>+        ::PostQuitMessage(0);
>+    });
>+}
> 
>-    return !!::RegisterClass(&windowClass);
>+void RunLoop::registerRunLoopMessageWindowClass()
>+{
>+    static std::once_flag onceKey;
>+    std::call_once(onceKey, [] {
>+        WNDCLASS windowClass = { 0 };
>+        windowClass.lpfnWndProc     = RunLoop::RunLoopWndProc;
>+        windowClass.cbWndExtra      = sizeof(RunLoop*);
>+        windowClass.lpszClassName   = kRunLoopMessageWindowClassName;
>+        bool result = !!::RegisterClass(&windowClass);
>+        RELEASE_ASSERT(result);
>+    });
> }
> 
> RunLoop::RunLoop()
>@@ -102,7 +116,6 @@ RunLoop::RunLoop()
> 
> RunLoop::~RunLoop()
> {
>-    // FIXME: Tear down the work item queue here.
> }
> 
> void RunLoop::wakeUp()
>@@ -114,39 +127,23 @@ void RunLoop::wakeUp()
> 
> // RunLoop::Timer
> 
>-void RunLoop::TimerBase::timerFired(RunLoop* runLoop, uint64_t ID)
>+void RunLoop::TimerBase::timerFired()
> {
>-    TimerBase* timer = nullptr;
>     {
>-        LockHolder locker(runLoop->m_activeTimersLock);
>-        TimerMap::iterator it = runLoop->m_activeTimers.find(ID);
>-        if (it == runLoop->m_activeTimers.end()) {
>-            // The timer must have been stopped after the WM_TIMER message was posted to the message queue.
>+        LockHolder locker(m_runLoop->m_loopLock);
>+        if (!m_isActive)
>             return;
>-        }
>-
>-        timer = it->value;
> 
>-        if (!timer->m_isRepeating) {
>-            runLoop->m_activeTimers.remove(it);
>-            ::KillTimer(runLoop->m_runLoopMessageWindow, ID);
>-        } else
>-            timer->m_nextFireDate = MonotonicTime::now() + timer->m_interval;
>+        if (!m_isRepeating)
>+            ::KillTimer(m_runLoop->m_runLoopMessageWindow, bitwise_cast<uintptr_t>(this));
>+        else
>+            m_nextFireDate = MonotonicTime::now() + m_interval;
>     }
>-
>-    timer->fired();
>-}
>-
>-static uint64_t generateTimerID()
>-{
>-    static uint64_t uniqueTimerID = 1;
>-    return uniqueTimerID++;
>+    fired();
> }
> 
> RunLoop::TimerBase::TimerBase(RunLoop& runLoop)
>     : m_runLoop(runLoop)
>-    , m_ID(generateTimerID())
>-    , m_isRepeating(false)
> {
> }
> 
>@@ -157,39 +154,36 @@ RunLoop::TimerBase::~TimerBase()
> 
> void RunLoop::TimerBase::start(Seconds nextFireInterval, bool repeat)
> {
>-    LockHolder locker(m_runLoop->m_activeTimersLock);
>+    LockHolder locker(m_runLoop->m_loopLock);
>     m_isRepeating = repeat;
>-    m_runLoop->m_activeTimers.set(m_ID, this);
>+    m_isActive = true;
>     m_interval = nextFireInterval;
>     m_nextFireDate = MonotonicTime::now() + m_interval;
>-    ::SetTimer(m_runLoop->m_runLoopMessageWindow, m_ID, nextFireInterval.millisecondsAs<unsigned>(), 0);
>+    ::SetTimer(m_runLoop->m_runLoopMessageWindow, bitwise_cast<uintptr_t>(this), nextFireInterval.millisecondsAs<UINT>(), 0);
> }
> 
> void RunLoop::TimerBase::stop()
> {
>-    LockHolder locker(m_runLoop->m_activeTimersLock);
>-    TimerMap::iterator it = m_runLoop->m_activeTimers.find(m_ID);
>-    if (it == m_runLoop->m_activeTimers.end())
>+    LockHolder locker(m_runLoop->m_loopLock);
>+    if (!isActive(locker))
>         return;
>-
>-    m_runLoop->m_activeTimers.remove(it);
>-    ::KillTimer(m_runLoop->m_runLoopMessageWindow, m_ID);
>+    ::KillTimer(m_runLoop->m_runLoopMessageWindow, bitwise_cast<uintptr_t>(this));
> }
> 
> bool RunLoop::TimerBase::isActive(const AbstractLocker&) const
> {
>-    return m_runLoop->m_activeTimers.contains(m_ID);
>+    return m_isActive;
> }
> 
> bool RunLoop::TimerBase::isActive() const
> {
>-    LockHolder locker(m_runLoop->m_activeTimersLock);
>+    LockHolder locker(m_runLoop->m_loopLock);
>     return isActive(locker);
> }
> 
> Seconds RunLoop::TimerBase::secondsUntilFire() const
> {
>-    LockHolder locker(m_runLoop->m_activeTimersLock);
>+    LockHolder locker(m_runLoop->m_loopLock);
>     if (isActive(locker))
>         return std::max<Seconds>(m_nextFireDate - MonotonicTime::now(), 0_s);
>     return 0_s;
>diff --git a/Tools/ChangeLog b/Tools/ChangeLog
>index 92e52145c54ab0b7f2e8a2adb0c73edb70483a77..b6c5d250ca28f3980e5deb6aeeedc89e6a4fa81f 100644
>--- a/Tools/ChangeLog
>+++ b/Tools/ChangeLog
>@@ -1,3 +1,27 @@
>+2018-04-26  Yusuke Suzuki  <utatane.tea@gmail.com>
>+
>+        [WTF] Align assumption in RunLoopWin to the other platform's RunLoop
>+        https://bugs.webkit.org/show_bug.cgi?id=181151
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * TestWebKitAPI/CMakeLists.txt:
>+        * TestWebKitAPI/PlatformJSCOnly.cmake:
>+        * TestWebKitAPI/PlatformMac.cmake:
>+        * TestWebKitAPI/PlatformUtilities.h:
>+        * TestWebKitAPI/PlatformWin.cmake:
>+        Enable TestWTF RunLoop tests in all platforms.
>+
>+        * TestWebKitAPI/Tests/WTF/RunLoop.cpp:
>+        (TestWebKitAPI::DerivedOneShotTimer::DerivedOneShotTimer):
>+        (TestWebKitAPI::DerivedOneShotTimer::fired):
>+        (TestWebKitAPI::TEST):
>+        Only a few platforms support nested RunLoop.
>+
>+        (TestWebKitAPI::DerivedRepeatingTimer::DerivedRepeatingTimer):
>+        (TestWebKitAPI::DerivedRepeatingTimer::fired):
>+        * TestWebKitAPI/config.h:
>+
> 2018-04-25  Michael Catanzaro  <mcatanzaro@igalia.com>
> 
>         [WPE] Build and link against latest WPEBackend and WPEBackend-fdo
>diff --git a/Tools/TestWebKitAPI/CMakeLists.txt b/Tools/TestWebKitAPI/CMakeLists.txt
>index eb78e9a8c7fb76680f8f9af49e607a74540a30dd..2baa9ab00f0b23128d723dc24d90e7c9a7288a5c 100644
>--- a/Tools/TestWebKitAPI/CMakeLists.txt
>+++ b/Tools/TestWebKitAPI/CMakeLists.txt
>@@ -134,6 +134,7 @@ set(TestWTF_SOURCES
>     ${TESTWEBKITAPI_DIR}/Tests/WTF/RefCounter.cpp
>     ${TESTWEBKITAPI_DIR}/Tests/WTF/RefLogger.cpp
>     ${TESTWEBKITAPI_DIR}/Tests/WTF/RefPtr.cpp
>+    ${TESTWEBKITAPI_DIR}/Tests/WTF/RunLoop.cpp
>     ${TESTWEBKITAPI_DIR}/Tests/WTF/SHA1.cpp
>     ${TESTWEBKITAPI_DIR}/Tests/WTF/SaturatedArithmeticOperations.cpp
>     ${TESTWEBKITAPI_DIR}/Tests/WTF/Scope.cpp
>@@ -160,9 +161,7 @@ set(TestWTF_SOURCES
>     ${TESTWEBKITAPI_DIR}/Tests/WTF/WorkQueue.cpp
> )
> 
>-# FIXME: Tests/WTF/RunLoop.cpp is missing because it doesn't work for Windows.
> # FIXME: Platform-specific sources in Tests/WTF are not included in TestWTF_SOURCES.
>-
> WEBKIT_INCLUDE_CONFIG_FILES_IF_EXISTS()
> 
> include_directories(
>diff --git a/Tools/TestWebKitAPI/PlatformJSCOnly.cmake b/Tools/TestWebKitAPI/PlatformJSCOnly.cmake
>index 7e53f86e298b5f67b09a7564da7a6bd22de4afec..2eed56b833e80a4e0c36df7cc3cded3c974d65f1 100644
>--- a/Tools/TestWebKitAPI/PlatformJSCOnly.cmake
>+++ b/Tools/TestWebKitAPI/PlatformJSCOnly.cmake
>@@ -17,5 +17,4 @@ set(test_main_SOURCES
> 
> list(APPEND TestWTF_SOURCES
>     ${TESTWEBKITAPI_DIR}/jsconly/PlatformUtilitiesJSCOnly.cpp
>-    ${TESTWEBKITAPI_DIR}/Tests/WTF/RunLoop.cpp
> )
>diff --git a/Tools/TestWebKitAPI/PlatformMac.cmake b/Tools/TestWebKitAPI/PlatformMac.cmake
>index f89598f572337b0bd3849c11feefb8a16e1dc284..9cad3e5b06c92237ac705876514fc1746072553e 100644
>--- a/Tools/TestWebKitAPI/PlatformMac.cmake
>+++ b/Tools/TestWebKitAPI/PlatformMac.cmake
>@@ -34,3 +34,7 @@ set(bundle_harness_SOURCES
>     ${TESTWEBKITAPI_DIR}/mac/SyntheticBackingScaleFactorWindow.m
>     ${TESTWEBKITAPI_DIR}/mac/TestBrowsingContextLoadDelegate.mm
> )
>+
>+list(APPEND TestWTF_SOURCES
>+    ${TESTWEBKITAPI_DIR}/cocoa/UtilitiesCocoa.mm
>+)
>diff --git a/Tools/TestWebKitAPI/PlatformUtilities.h b/Tools/TestWebKitAPI/PlatformUtilities.h
>index e1e309e6931f71ade97d6208d9b8c59587ec59bc..c30ac960a3d607490bad217ee3eb9fca0f2c6fe4 100644
>--- a/Tools/TestWebKitAPI/PlatformUtilities.h
>+++ b/Tools/TestWebKitAPI/PlatformUtilities.h
>@@ -26,7 +26,7 @@
> #ifndef PlatformUtilities_h
> #define PlatformUtilities_h
> 
>-#ifndef BUILDING_JSCONLY__
>+#if WK_HAVE_C_SPI
> #include <WebKit/WKNativeEvent.h>
> #include <WebKit/WKRetainPtr.h>
> #endif
>diff --git a/Tools/TestWebKitAPI/PlatformWin.cmake b/Tools/TestWebKitAPI/PlatformWin.cmake
>index c8b44dbdd09bf56e256cdda4df107f8393ecee1f..c35c86b15e9bb79ff38884e5e49ffcdd7c1ba1f1 100644
>--- a/Tools/TestWebKitAPI/PlatformWin.cmake
>+++ b/Tools/TestWebKitAPI/PlatformWin.cmake
>@@ -98,6 +98,10 @@ if (USE_CF)
>     )
> endif ()
> 
>+list(APPEND TestWTF_SOURCES
>+    ${TESTWEBKITAPI_DIR}/win/UtilitiesWin.cpp
>+)
>+
> add_library(TestWTFLib SHARED
>     ${test_main_SOURCES}
>     ${TestWTF_SOURCES}
>@@ -109,8 +113,6 @@ add_dependencies(TestWTFLib WebCoreForwardingHeaders)
> set(test_wtf_LIBRARIES
>     shlwapi
> )
>-set(TestWTF_SOURCES
>-)
> 
> add_library(TestWebCoreLib SHARED
>     ${TestWebCoreLib_SOURCES}
>diff --git a/Tools/TestWebKitAPI/Tests/WTF/RunLoop.cpp b/Tools/TestWebKitAPI/Tests/WTF/RunLoop.cpp
>index 93b3d8c28f3208176cd3bc52b7f9e3d614a07917..9350b0e6fcb6c952ec50d214c4d55e162a2ee471 100644
>--- a/Tools/TestWebKitAPI/Tests/WTF/RunLoop.cpp
>+++ b/Tools/TestWebKitAPI/Tests/WTF/RunLoop.cpp
>@@ -27,6 +27,7 @@
> 
> #include "Utilities.h"
> #include <wtf/RunLoop.h>
>+#include <wtf/Threading.h>
> 
> namespace TestWebKitAPI {
> 
>@@ -54,90 +55,69 @@ TEST(WTF_RunLoop, Deadlock)
>     Util::run(&testFinished);
> }
> 
>-TEST(WTF_RunLoop, NestedRunLoop)
>-{
>-    RunLoop::initializeMainRunLoop();
>+class DerivedOneShotTimer : public RunLoop::Timer<DerivedOneShotTimer> {
>+public:
>+    DerivedOneShotTimer(bool& testFinished)
>+        : RunLoop::Timer<DerivedOneShotTimer>(RunLoop::current(), this, &DerivedOneShotTimer::fired)
>+        , m_testFinished(testFinished)
>+    {
>+    }
> 
>-    bool testFinished = false;
>-    RunLoop::current().dispatch([&] {
>-        RunLoop::current().dispatch([&] {
>-            testFinished = true;
>-        });
>-        Util::run(&testFinished);
>-    });
>+    void fired()
>+    {
>+        m_testFinished = true;
>+        stop();
>+    }
>+
>+private:
>+    bool& m_testFinished;
>+};
> 
>-    Util::run(&testFinished);
>-}
> 
> TEST(WTF_RunLoop, OneShotTimer)
> {
>     RunLoop::initializeMainRunLoop();
> 
>     bool testFinished = false;
>+    DerivedOneShotTimer timer(testFinished);
>+    timer.startOneShot(100_ms);
>+    Util::run(&testFinished);
>+}
> 
>-    class DerivedTimer : public RunLoop::Timer<DerivedTimer> {
>-    public:
>-        DerivedTimer(bool& testFinished)
>-            : RunLoop::Timer<DerivedTimer>(RunLoop::current(), this, &DerivedTimer::fired)
>-            , m_testFinished(testFinished)
>-        {
>-        }
>+class DerivedRepeatingTimer : public RunLoop::Timer<DerivedRepeatingTimer> {
>+public:
>+    DerivedRepeatingTimer(bool& testFinished)
>+        : RunLoop::Timer<DerivedRepeatingTimer>(RunLoop::current(), this, &DerivedRepeatingTimer::fired)
>+        , m_testFinished(testFinished)
>+    {
>+    }
> 
>-        void fired()
>-        {
>+    void fired()
>+    {
>+        if (++m_count == 10) {
>             m_testFinished = true;
>             stop();
>         }
>+    }
> 
>-    private:
>-        bool& m_testFinished;
>-    };
>+private:
>+    unsigned m_count { 0 };
>+    bool& m_testFinished;
>+};
> 
>-    {
>-        DerivedTimer timer(testFinished);
>-        timer.startOneShot(100_ms);
>-        Util::run(&testFinished);
>-    }
>-}
> 
> TEST(WTF_RunLoop, RepeatingTimer)
> {
>     RunLoop::initializeMainRunLoop();
> 
>     bool testFinished = false;
>-
>-    class DerivedTimer : public RunLoop::Timer<DerivedTimer> {
>-    public:
>-        DerivedTimer(bool& testFinished)
>-            : RunLoop::Timer<DerivedTimer>(RunLoop::current(), this, &DerivedTimer::fired)
>-            , m_testFinished(testFinished)
>-        {
>-        }
>-
>-        void fired()
>-        {
>-            if (++m_count == 10) {
>-                m_testFinished = true;
>-                stop();
>-            }
>-        }
>-
>-    private:
>-        unsigned m_count { 0 };
>-        bool& m_testFinished;
>-    };
>-
>-    {
>-        DerivedTimer timer(testFinished);
>-        timer.startRepeating(10_ms);
>-        Util::run(&testFinished);
>-    }
>+    DerivedRepeatingTimer timer(testFinished);
>+    timer.startRepeating(10_ms);
>+    Util::run(&testFinished);
> }
> 
> TEST(WTF_RunLoop, ManyTimes)
> {
>-    RunLoop::initializeMainRunLoop();
>-
>     class Counter {
>     public:
>         void run()
>@@ -155,12 +135,13 @@ TEST(WTF_RunLoop, ManyTimes)
>         unsigned m_count { 0 };
>     };
> 
>-    Counter counter;
>-
>-    RunLoop::current().dispatch([&counter] {
>-        counter.run();
>-    });
>-    RunLoop::run();
>+    Thread::create("RunLoopManyTimes", [] {
>+        Counter counter;
>+        RunLoop::current().dispatch([&counter] {
>+            counter.run();
>+        });
>+        RunLoop::run();
>+    })->waitForCompletion();
> }
> 
> } // namespace TestWebKitAPI
>diff --git a/Tools/TestWebKitAPI/config.h b/Tools/TestWebKitAPI/config.h
>index a3aa45aac17dcf888f570dab6819e1775fa0549b..410054b03c54b407a6f8e26ed1af23b9f0085de9 100644
>--- a/Tools/TestWebKitAPI/config.h
>+++ b/Tools/TestWebKitAPI/config.h
>@@ -71,6 +71,6 @@
> #endif
> #endif
> 
>-#if !PLATFORM(IOS) && !defined(BUILDING_JSCONLY__)
>+#if !PLATFORM(IOS) && !defined(BUILDING_JSCONLY__) && !PLATFORM(WIN)
> #define WK_HAVE_C_SPI 1
> #endif

Actions: View | Formatted Diff | Diff

Attachments on bug 181151: 330179 | 330180 | 330181 | 330182 | 330185 | 331860 | 331861 | 331866 | 331867 | 331869 | 331870 | 331871 | 331889 | 331894 | 338719 | 338725 | 338740 | 338742 | 338748 | 338904 | 338905 | 340264 | 363711 | 363721 | 363987 | 363994