Changeset 162235 in webkit

Timestamp:

Jan 17, 2014 5:58:16 PM (10 years ago)

Author:

andersca@apple.com

Message:

Add a callOnMainThreadAndWait variant in SocketStreamHandle
​https://bugs.webkit.org/show_bug.cgi?id=127180

Reviewed by Geoffrey Garen.

Source/WebCore:

WTF::callOnMainThreadAndWait was only used inside SocketStreamHandleCFNet.cpp,
so add an improved version there which is implemented in terms of callOnMainThread and
with the bonus of handling spurious wake-ups correctly (the old version didn't).

• platform/network/cf/SocketStreamHandle.h:
• platform/network/cf/SocketStreamHandleCFNet.cpp:

(WebCore::callOnMainThreadAndWait):
(WebCore::SocketStreamHandle::pacExecutionCallback):
(WebCore::SocketStreamHandle::readStreamCallback):
(WebCore::SocketStreamHandle::writeStreamCallback):

Source/WTF:

Remove callOnMainThreadAndWait from WTF.

• wtf/MainThread.cpp:
• wtf/MainThread.h:

Location:

trunk/Source

Files:

• WTF/ChangeLog (modified) (1 diff)
• WTF/wtf/MainThread.cpp (modified) (1 diff)
• WTF/wtf/MainThread.h (modified) (2 diffs)
• WebCore/ChangeLog (modified) (1 diff)
• WebCore/platform/network/cf/SocketStreamHandle.h (modified) (2 diffs)
• WebCore/platform/network/cf/SocketStreamHandleCFNet.cpp (modified) (7 diffs)

trunk/Source/WTF/ChangeLog

@@ +1 @@
+2014-01-17  Anders Carlsson  <andersca@apple.com>
+
+        Add a callOnMainThreadAndWait variant in SocketStreamHandle
+        https://bugs.webkit.org/show_bug.cgi?id=127180
+
+        Reviewed by Geoffrey Garen.
+
+        Remove callOnMainThreadAndWait from WTF.
+
+        * wtf/MainThread.cpp:
+        * wtf/MainThread.h:
+
 2014-01-17  Peter Molnar  <pmolnar.u-szeged@partner.samsung.com>
 

trunk/Source/WTF/wtf/MainThread.cpp

@@ -195 +195 @@
 }
 
-void callOnMainThreadAndWait(MainThreadFunction* function, void* context)
-{
-    ASSERT(function);
-
-    if (isMainThread()) {
-        function(context);
-        return;
-    }
-
-    ThreadCondition syncFlag;
-    Mutex& functionQueueMutex = mainThreadFunctionQueueMutex();
-    MutexLocker locker(functionQueueMutex);
-    functionQueue().append(FunctionWithContext(function, context, &syncFlag));
-    if (functionQueue().size() == 1)
-        scheduleDispatchFunctionsOnMainThread();
-    syncFlag.wait(functionQueueMutex);
-}
-
 void cancelCallOnMainThread(MainThreadFunction* function, void* context)
 {

trunk/Source/WTF/wtf/MainThread.h

@@ -43 +43 @@
 
 WTF_EXPORT_PRIVATE void callOnMainThread(MainThreadFunction*, void* context);
-WTF_EXPORT_PRIVATE void callOnMainThreadAndWait(MainThreadFunction*, void* context);
 WTF_EXPORT_PRIVATE void cancelCallOnMainThread(MainThreadFunction*, void* context);
 
@@ -95 +94 @@
 
 using WTF::callOnMainThread;
-using WTF::callOnMainThreadAndWait;
 using WTF::cancelCallOnMainThread;
 using WTF::setMainThreadCallbacksPaused;

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2014-01-17  Anders Carlsson  <andersca@apple.com>
+
+        Add a callOnMainThreadAndWait variant in SocketStreamHandle
+        https://bugs.webkit.org/show_bug.cgi?id=127180
+
+        Reviewed by Geoffrey Garen.
+
+        WTF::callOnMainThreadAndWait was only used inside SocketStreamHandleCFNet.cpp, 
+        so add an improved version there which is implemented in terms of callOnMainThread and
+        with the bonus of handling spurious wake-ups correctly (the old version didn't).
+
+        * platform/network/cf/SocketStreamHandle.h:
+        * platform/network/cf/SocketStreamHandleCFNet.cpp:
+        (WebCore::callOnMainThreadAndWait):
+        (WebCore::SocketStreamHandle::pacExecutionCallback):
+        (WebCore::SocketStreamHandle::readStreamCallback):
+        (WebCore::SocketStreamHandle::writeStreamCallback):
+
 2014-01-17  Anders Carlsson  <andersca@apple.com>
 

trunk/Source/WebCore/platform/network/cf/SocketStreamHandle.h

@@ -67 +67 @@
     RetainPtr<CFRunLoopSourceRef> m_pacRunLoopSource;
     static void pacExecutionCallback(void* client, CFArrayRef proxyList, CFErrorRef error);
-    static void pacExecutionCallbackMainThread(void*);
     static CFStringRef copyPACExecutionDescription(void*);
 
@@ -80 +79 @@
     static void readStreamCallback(CFReadStreamRef, CFStreamEventType, void*);
     static void writeStreamCallback(CFWriteStreamRef, CFStreamEventType, void*);
-#if PLATFORM(WIN)
-    static void readStreamCallbackMainThread(void*);
-    static void writeStreamCallbackMainThread(void*);
-#endif
     void readStreamCallback(CFStreamEventType);
     void writeStreamCallback(CFStreamEventType);

trunk/Source/WebCore/platform/network/cf/SocketStreamHandleCFNet.cpp

@@ -39 +39 @@
 #include "SocketStreamError.h"
 #include "SocketStreamHandleClient.h"
+#include <condition_variable>
+#include <mutex>
 #include <wtf/MainThread.h>
 #include <wtf/text/WTFString.h>
@@ -126 +128 @@
 }
 
+static void callOnMainThreadAndWait(std::function<void ()> function)
+{
+    if (isMainThread()) {
+        function();
+        return;
+    }
+
+    std::mutex mutex;
+    std::condition_variable conditionVariable;
+
+    bool isFinished = false;
+
+    callOnMainThread([&] {
+        function();
+
+        std::lock_guard<std::mutex> lock(mutex);
+        isFinished = true;
+        conditionVariable.notify_one();
+    });
+
+    std::unique_lock<std::mutex> lock(mutex);
+    conditionVariable.wait(lock, [&] { return isFinished; });
+}
+
 struct MainThreadPACCallbackInfo {
     MainThreadPACCallbackInfo(SocketStreamHandle* handle, CFArrayRef proxyList) : handle(handle), proxyList(proxyList) { }
@@ -135 +161 @@
 {
     SocketStreamHandle* handle = static_cast<SocketStreamHandle*>(client);
-    MainThreadPACCallbackInfo info(handle, proxyList);
-    // If we're already on main thread (e.g. on Mac), callOnMainThreadAndWait() will be just a function call.
-    callOnMainThreadAndWait(pacExecutionCallbackMainThread, &info);
-}
-
-void SocketStreamHandle::pacExecutionCallbackMainThread(void* invocation)
-{
-    MainThreadPACCallbackInfo* info = static_cast<MainThreadPACCallbackInfo*>(invocation);
-    ASSERT(info->handle->m_connectingSubstate == ExecutingPACFile);
-    // This time, the array won't have PAC as a first entry.
-    if (info->handle->m_state != Connecting)
-        return;
-    info->handle->chooseProxyFromArray(info->proxyList);
-    info->handle->createStreams();
-    info->handle->scheduleStreams();
+
+    callOnMainThreadAndWait([&] {
+        ASSERT(handle->m_connectingSubstate == ExecutingPACFile);
+        // This time, the array won't have PAC as a first entry.
+        if (handle->m_state != Connecting)
+            return;
+        handle->chooseProxyFromArray(proxyList);
+        handle->createStreams();
+        handle->scheduleStreams();
+    });
 }
 
@@ -400 +421 @@
 }
 
-struct MainThreadEventCallbackInfo {
-    MainThreadEventCallbackInfo(CFStreamEventType type, SocketStreamHandle* handle) : type(type), handle(handle) { }
-    CFStreamEventType type;
-    RefPtr<SocketStreamHandle> handle;
-};
-
 void SocketStreamHandle::readStreamCallback(CFReadStreamRef stream, CFStreamEventType type, void* clientCallBackInfo)
 {
@@ -411 +426 @@
     ASSERT_UNUSED(stream, stream == handle->m_readStream.get());
 #if PLATFORM(WIN)
-    MainThreadEventCallbackInfo info(type, handle);
-    callOnMainThreadAndWait(readStreamCallbackMainThread, &info);
+    callOnMainThreadAndWait([&] {
+        handle->readStreamCallback(type);
+    });
 #else
     ASSERT(isMainThread());
@@ -424 +440 @@
     ASSERT_UNUSED(stream, stream == handle->m_writeStream.get());
 #if PLATFORM(WIN)
-    MainThreadEventCallbackInfo info(type, handle);
-    callOnMainThreadAndWait(writeStreamCallbackMainThread, &info);
+    callOnMainThreadAndWait([&] {
+        handle->writeStreamCallback(type);
+    });
 #else
     ASSERT(isMainThread());
@@ -431 +448 @@
 #endif
 }
-
-#if PLATFORM(WIN)
-void SocketStreamHandle::readStreamCallbackMainThread(void* invocation)
-{
-    MainThreadEventCallbackInfo* info = static_cast<MainThreadEventCallbackInfo*>(invocation);
-    info->handle->readStreamCallback(info->type);
-}
-
-void SocketStreamHandle::writeStreamCallbackMainThread(void* invocation)
-{
-    MainThreadEventCallbackInfo* info = static_cast<MainThreadEventCallbackInfo*>(invocation);
-    info->handle->writeStreamCallback(info->type);
-}
-#endif // PLATFORM(WIN)
 
 void SocketStreamHandle::readStreamCallback(CFStreamEventType type)