WebKit Bugzilla
New
Browse
Search+
Log In
×
Sign in with GitHub
or
Remember my login
Create Account
·
Forgot Password
Forgotten password account recovery
[patch]
Patch
bug-90780-20120711173208.patch (text/plain), 131.80 KB, created by
Kwonjin Jeong
on 2012-07-11 01:32:41 PDT
(
hide
)
Description:
Patch
Filename:
MIME Type:
Creator:
Kwonjin Jeong
Created:
2012-07-11 01:32:41 PDT
Size:
131.80 KB
patch
obsolete
>Subversion Revision: 122298 >diff --git a/Source/JavaScriptCore/ChangeLog b/Source/JavaScriptCore/ChangeLog >index a1cbefa369db240c5a2d98dd0d61ac2f0c1520fa..cf837a0cc9933a17740fd2100dcf03dc57274691 100644 >--- a/Source/JavaScriptCore/ChangeLog >+++ b/Source/JavaScriptCore/ChangeLog >@@ -1,3 +1,19 @@ >+2012-07-11 Kwonjin Jeong <gram@company100.net> >+ >+ Move WorkQueue to WTF >+ https://bugs.webkit.org/show_bug.cgi?id=90780 >+ >+ Reviewed by NOBODY (OOPS!). >+ >+ Currently, WorkQueue is in WebKit2. By moving WorkQueue and >+ PlatformProcessIdentifier to WTF, WebCore code can use it. >+ >+ This patch is required for parallel image decoders because >+ WorkQueue is used to make image decoding off the main thread. >+ >+ * JavaScriptCore.order: >+ * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def: >+ > 2012-07-10 Filip Pizlo <fpizlo@apple.com> > > REGRESSION(r122166): It made 170 tests crash on 32 bit platforms >diff --git a/Source/WTF/ChangeLog b/Source/WTF/ChangeLog >index 066f975d9a2c1582d6c3d98ccdee0bb37965e7a0..782784448edda53d9fd226e7dcfe4d022d0cc642 100644 >--- a/Source/WTF/ChangeLog >+++ b/Source/WTF/ChangeLog >@@ -1,3 +1,130 @@ >+2012-07-11 Kwonjin Jeong <gram@company100.net> >+ >+ Move WorkQueue to WTF >+ https://bugs.webkit.org/show_bug.cgi?id=90780 >+ >+ Reviewed by NOBODY (OOPS!). >+ >+ Currently, WorkQueue is in WebKit2. By moving WorkQueue and >+ PlatformProcessIdentifier to WTF, WebCore code can use it. >+ >+ This patch is required for parallel image decoders because >+ WorkQueue is used to make image decoding off the main thread. >+ >+ * GNUmakefile.list.am: >+ * WTF.pro: >+ * WTF.vcproj/WTF.vcproj: >+ * WTF.xcodeproj/project.pbxproj: >+ * wtf/CMakeLists.txt: >+ * wtf/PlatformEfl.cmake: >+ * wtf/PlatformProcessIdentifier.h: Renamed from Source/WebKit2/Platform/PlatformProcessIdentifier.h. >+ (WTF): >+ * wtf/WorkQueue.cpp: Renamed from Source/WebKit2/Platform/WorkQueue.cpp. >+ (WTF): >+ (WTF::WorkQueue::WorkQueue): >+ (WTF::WorkQueue::~WorkQueue): >+ (WTF::WorkQueue::invalidate): >+ * wtf/WorkQueue.h: Renamed from Source/WebKit2/Platform/WorkQueue.h. >+ (WTF): >+ (WorkQueue): >+ (WorkItemWin): >+ (WTF::WorkQueue::WorkItemWin::function): >+ (WTF::WorkQueue::WorkItemWin::queue): >+ (HandleWorkItem): >+ (WTF::WorkQueue::HandleWorkItem::setWaitHandle): >+ (WTF::WorkQueue::HandleWorkItem::waitHandle): >+ * wtf/efl/WorkQueueEfl.cpp: Renamed from Source/WebKit2/Platform/efl/WorkQueueEfl.cpp. >+ (TimerWorkItem): >+ (TimerWorkItem::TimerWorkItem): >+ (TimerWorkItem::~TimerWorkItem): >+ (TimerWorkItem::function): >+ (TimerWorkItem::queue): >+ (TimerWorkItem::timerID): >+ (WorkQueue::platformInitialize): >+ (WorkQueue::platformInvalidate): >+ (WorkQueue::performWork): >+ (WorkQueue::performFileDescriptorWork): >+ (WorkQueue::sendMessageToThread): >+ (WorkQueue::workQueueThread): >+ (WorkQueue::registerSocketEventHandler): >+ (WorkQueue::unregisterSocketEventHandler): >+ (WorkQueue::dispatch): >+ (WorkQueue::timerFired): >+ (WorkQueue::dispatchAfterDelay): >+ * wtf/gtk/WorkQueueGtk.cpp: Renamed from Source/WebKit2/Platform/gtk/WorkQueueGtk.cpp. >+ (WorkQueue::EventSource): >+ (WorkQueue::EventSource::EventSource): >+ (WorkQueue::EventSource::cancel): >+ (WorkQueue::EventSource::executeEventSource): >+ (WorkQueue::EventSource::performWorkOnce): >+ (WorkQueue::EventSource::performWork): >+ (WorkQueue::EventSource::performWorkOnTermination): >+ (WorkQueue::EventSource::deleteEventSource): >+ (WorkQueue::platformInitialize): >+ (WorkQueue::platformInvalidate): >+ (WorkQueue::startWorkQueueThread): >+ (WorkQueue::workQueueThreadBody): >+ (WorkQueue::registerEventSourceHandler): >+ (WorkQueue::unregisterEventSourceHandler): >+ (WorkQueue::dispatchOnSource): >+ (WorkQueue::dispatch): >+ (WorkQueue::dispatchAfterDelay): >+ (WorkQueue::dispatchOnTermination): >+ * wtf/mac/WorkQueueMac.cpp: Renamed from Source/WebKit2/Platform/mac/WorkQueueMac.cpp. >+ (WTF): >+ (WTF::WorkQueue::executeFunction): >+ (WTF::WorkQueue::dispatch): >+ (WTF::WorkQueue::dispatchAfterDelay): >+ (WorkQueue::EventSource): >+ (WTF::WorkQueue::EventSource::EventSource): >+ (WTF::WorkQueue::EventSource::dispatchSource): >+ (WTF::WorkQueue::EventSource::eventHandler): >+ (WTF::WorkQueue::EventSource::cancelHandler): >+ (WTF::WorkQueue::EventSource::finalizeHandler): >+ (WTF::WorkQueue::registerMachPortEventHandler): >+ (WTF::WorkQueue::unregisterMachPortEventHandler): >+ (WTF::WorkQueue::platformInitialize): >+ (WTF::WorkQueue::platformInvalidate): >+ * wtf/qt/WorkQueueQt.cpp: Renamed from Source/WebKit2/Platform/qt/WorkQueueQt.cpp. >+ (WTF): >+ (WorkQueue::WorkItemQt): >+ (WTF::WorkQueue::WorkItemQt::WorkItemQt): >+ (WTF::WorkQueue::WorkItemQt::~WorkItemQt): >+ (WTF::WorkQueue::WorkItemQt::execute): >+ (WTF::WorkQueue::WorkItemQt::executeAndDelete): >+ (WTF::WorkQueue::WorkItemQt::timerEvent): >+ (WTF::WorkQueue::registerSocketEventHandler): >+ (WTF::WorkQueue::platformInitialize): >+ (WTF::WorkQueue::platformInvalidate): >+ (WTF::WorkQueue::dispatch): >+ (WTF::WorkQueue::dispatchAfterDelay): >+ (WTF::WorkQueue::dispatchOnTermination): >+ * wtf/win/WorkQueueWin.cpp: Renamed from Source/WebKit2/Platform/win/WorkQueueWin.cpp. >+ (WTF): >+ (WTF::WorkQueue::WorkItemWin::WorkItemWin): >+ (WTF::WorkQueue::WorkItemWin::create): >+ (WTF::WorkQueue::WorkItemWin::~WorkItemWin): >+ (WTF::WorkQueue::HandleWorkItem::HandleWorkItem): >+ (WTF::WorkQueue::HandleWorkItem::createByAdoptingHandle): >+ (WTF::WorkQueue::HandleWorkItem::~HandleWorkItem): >+ (WTF::WorkQueue::handleCallback): >+ (WTF::WorkQueue::registerHandle): >+ (WTF::WorkQueue::unregisterAndCloseHandle): >+ (WTF::WorkQueue::workThreadCallback): >+ (WTF::WorkQueue::performWorkOnRegisteredWorkThread): >+ (WTF::WorkQueue::platformInitialize): >+ (WTF::WorkQueue::tryRegisterAsWorkThread): >+ (WTF::WorkQueue::unregisterAsWorkThread): >+ (WTF::WorkQueue::platformInvalidate): >+ (WTF::WorkQueue::dispatch): >+ (WTF::TimerContext::create): >+ (TimerContext): >+ (WTF::TimerContext::TimerContext): >+ (WTF::WorkQueue::timerCallback): >+ (WTF::WorkQueue::dispatchAfterDelay): >+ (WTF::WorkQueue::unregisterWaitAndDestroyItemSoon): >+ (WTF::WorkQueue::unregisterWaitAndDestroyItemCallback): >+ > 2012-07-10 Jocelyn Turcotte <jocelyn.turcotte@nokia.com> > > Re-enable __declspec(dl{import,export}) for MinGW when using EXPORT_MACROS >diff --git a/Source/WebKit2/ChangeLog b/Source/WebKit2/ChangeLog >index f8712e2b926136ea7d6629b03c99d2cb2bd2f899..432c653a778f403bcc9edeed7712cfe6afe2bcd8 100644 >--- a/Source/WebKit2/ChangeLog >+++ b/Source/WebKit2/ChangeLog >@@ -1,3 +1,32 @@ >+2012-07-11 Kwonjin Jeong <gram@company100.net> >+ >+ Move WorkQueue to WTF >+ https://bugs.webkit.org/show_bug.cgi?id=90780 >+ >+ Reviewed by NOBODY (OOPS!). >+ >+ Currently, WorkQueue is in WebKit2. By moving WorkQueue and >+ PlatformProcessIdentifier to WTF, WebCore code can use it. >+ >+ This patch is required for parallel image decoders because >+ WorkQueue is used to make image decoding off the main thread. >+ >+ * CMakeLists.txt: >+ * GNUmakefile.list.am: >+ * Platform/CoreIPC/Connection.h: >+ (Connection): >+ * Platform/CoreIPC/unix/ConnectionUnix.cpp: >+ (CoreIPC::Connection::setShouldCloseConnectionOnProcessTermination): >+ * PlatformEfl.cmake: >+ * Target.pri: >+ * UIProcess/Launcher/ProcessLauncher.cpp: >+ * UIProcess/Launcher/ProcessLauncher.h: >+ * UIProcess/Launcher/ThreadLauncher.h: >+ * UIProcess/WebPageProxy.h: >+ * UIProcess/WebProcessProxy.h: >+ * WebKit2.xcodeproj/project.pbxproj: >+ * win/WebKit2.vcproj: >+ > 2012-07-10 No'am Rosenthal <noam.rosenthal@nokia.com> > > [Qt] Enable antialiasing for TextureMapper >diff --git a/Source/JavaScriptCore/JavaScriptCore.order b/Source/JavaScriptCore/JavaScriptCore.order >index 3a450075a1343e59e7b1eda11a5f7cd803c865aa..7497d9f036290f4ccc892a60ef99a98b1ee5e6ba 100644 >--- a/Source/JavaScriptCore/JavaScriptCore.order >+++ b/Source/JavaScriptCore/JavaScriptCore.order >@@ -2494,3 +2494,10 @@ __ZN3WTF6VectorIN3JSC10ASTBuilder14AssignmentInfoELm10EE14expandCapacityEm > _cti_op_put_by_id_direct_generic > __ZN3WTF9HashTableIPN3JSC16FunctionBodyNodeESt4pairIS3_jENS_18PairFirstExtractorIS5_EENS_7PtrHashIS3_EENS_14PairHashTraitsINS_10HashTraitsIS3_EENSB_IjEEEESC_E4findIS3_NS_22IdentityHashTranslatorIS3_S5_S9_EEEENS_17HashTableIteratorIS3_S5_S7_S9_SE_SC_EERKT_ > __ZN3WTF9HashTableIPN3JSC16FunctionBodyNodeESt4pairIS3_jENS_18PairFirstExtractorIS5_EENS_7PtrHashIS3_EENS_14PairHashTraitsINS_10HashTraitsIS3_EENSB_IjEEEESC_E6expandEv >+__ZN3WTF9WorkQueueC1EPKc >+__ZN3WTF9WorkQueueD1Ev >+__ZN3WTF9WorkQueue28registerMachPortEventHandlerEjNS0_17MachPortEventTypeERKNS_8FunctionIFvvEEE >+__ZN3WTF9WorkQueue30unregisterMachPortEventHandlerEj >+__ZN3WTF9WorkQueue8dispatchERKNS_8FunctionIFvvEEE >+__ZN3WTF9WorkQueue18dispatchAfterDelayERKNS_8FunctionIFvvEEEd >+__ZN3WTF9WorkQueue10invalidateEv >diff --git a/Source/JavaScriptCore/JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def b/Source/JavaScriptCore/JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def >index c50013ac13b0b386328668ff49f5e07ac7bd9c42..d0e63d3fd94271f4c90e6e6d98c7dcc037a4c485 100755 >--- a/Source/JavaScriptCore/JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def >+++ b/Source/JavaScriptCore/JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def >@@ -28,6 +28,7 @@ EXPORTS > ??0UString@JSC@@QAE@PB_W@Z > ??0UString@JSC@@QAE@PB_WI@Z > ??0WTFThreadData@WTF@@QAE@XZ >+ ??0WorkQueue@WTF@@QAE@PBD@Z > ??0YarrPattern@Yarr@JSC@@QAE@ABVUString@2@_N1PAPBD@Z > ??1ArrayBufferView@WTF@@UAE@XZ > ??1ClientData@JSGlobalData@JSC@@UAE@XZ >@@ -43,6 +44,7 @@ EXPORTS > ??1ThreadCondition@WTF@@QAE@XZ > ??1WTFThreadData@WTF@@QAE@XZ > ??1WeakHandleOwner@JSC@@UAE@XZ >+ ??1WorkQueue@WTF@@QAE@XZ > ??8JSC@@YA_NABVUString@0@0@Z > ??8WTF@@YA_NABVCString@0@0@Z > ?EcmaScriptConverter@DoubleToStringConverter@double_conversion@WTF@@SAABV123@XZ >@@ -157,6 +159,8 @@ EXPORTS > ?detachThread@WTF@@YAXI@Z > ?didTimeOut@TimeoutChecker@JSC@@QAE_NPAVExecState@2@@Z > ?deleteAllCompiledCode@Heap@JSC@@QAEXXZ >+ ?dispatch@WorkQueue@WTF@@QAEXABV?$Function@$$A6AXXZ@2@@Z >+ ?dispatchAfterDelay@WorkQueue@WTF@@QAEXABV?$Function@$$A6AXXZ@2@N@Z > ?displayName@JSFunction@JSC@@QAE?BVUString@2@PAVExecState@2@@Z > ?dtoa@WTF@@YAXQADNAA_NAAHAAI@Z > ?dumpAllOptions@Options@JSC@@SAXPAU_iobuf@@@Z >@@ -229,6 +233,7 @@ EXPORTS > ?initializeThreading@JSC@@YAXXZ > ?initializeThreading@WTF@@YAXXZ > ?interpret@Yarr@JSC@@YAIPAUBytecodePattern@12@ABVUString@2@IPAI@Z >+ ?invalidate@WorkQueue@WTF@@QAEXXZ > ?isAccessorDescriptor@PropertyDescriptor@JSC@@QBE_NXZ > ?isBusy@Heap@JSC@@QAE_NXZ > ?isDataDescriptor@PropertyDescriptor@JSC@@QBE_NXZ >@@ -281,6 +286,7 @@ EXPORTS > ?randomNumber@WTF@@YANXZ > ?recompileAllJSFunctions@Debugger@JSC@@QAEXPAVJSGlobalData@2@@Z > ?regExpFlags@JSC@@YA?AW4RegExpFlags@1@ABVUString@1@@Z >+ ?registerHandle@WorkQueue@WTF@@QAEXPAXABV?$Function@$$A6AXXZ@2@@Z > ?reifyString@StringBuilder@WTF@@ABEXXZ > ?releaseDecommitted@OSAllocator@WTF@@SAXPAXI@Z > ?releaseExecutableMemory@JSGlobalData@JSC@@QAEXXZ >@@ -363,6 +369,7 @@ EXPORTS > ?unlock@Mutex@WTF@@QAEXXZ > ?unlockAtomicallyInitializedStaticMutex@WTF@@YAXXZ > ?unprotect@Heap@JSC@@QAE_NVJSValue@2@@Z >+ ?unregisterAndCloseHandle@WorkQueue@WTF@@QAEXPAX@Z > ?utf8@UString@JSC@@QBE?AVCString@WTF@@_N@Z > ?validate@MarkStack@JSC@@KAXPAVJSCell@2@@Z > ?visitChildren@JSGlobalObject@JSC@@SAXPAVJSCell@2@AAVSlotVisitor@2@@Z >diff --git a/Source/WTF/GNUmakefile.list.am b/Source/WTF/GNUmakefile.list.am >index c5f48a6ce559a24cc20b70758df8bc4a84dc9eed..cf2a08e7c99e162ff9af1ff717d9c8ec8edd062a 100644 >--- a/Source/WTF/GNUmakefile.list.am >+++ b/Source/WTF/GNUmakefile.list.am >@@ -164,6 +164,8 @@ wtf_sources += \ > Source/WTF/wtf/ValueCheck.h \ > Source/WTF/wtf/Vector.h \ > Source/WTF/wtf/VectorTraits.h \ >+ Source/WTF/wtf/WorkQueue.cpp \ >+ Source/WTF/wtf/WorkQueue.h \ > Source/WTF/wtf/WTFThreadData.cpp \ > Source/WTF/wtf/WTFThreadData.h \ > Source/WTF/wtf/dtoa.cpp \ >@@ -194,6 +196,7 @@ wtf_sources += \ > Source/WTF/wtf/gobject/GlibUtilities.cpp \ > Source/WTF/wtf/gobject/GlibUtilities.h \ > Source/WTF/wtf/gtk/MainThreadGtk.cpp \ >+ Source/WTF/wtf/gtk/WorkQueueGtk.cpp \ > Source/WTF/wtf/text/ASCIIFastPath.h \ > Source/WTF/wtf/text/AtomicString.cpp \ > Source/WTF/wtf/text/AtomicString.h \ >diff --git a/Source/WTF/WTF.pro b/Source/WTF/WTF.pro >index 0962ef0b50a517bd0e2d4562df8defd6f51a1f04..886b2f3a7b6e3a855ddb0631bb767554e52758cb 100644 >--- a/Source/WTF/WTF.pro >+++ b/Source/WTF/WTF.pro >@@ -163,6 +163,7 @@ HEADERS += \ > Vector.h \ > VectorTraits.h \ > VMTags.h \ >+ WorkQueue.h \ > WTFThreadData.h > > unix: HEADERS += ThreadIdentifierDataPthreads.h >@@ -199,6 +200,7 @@ SOURCES += \ > OSRandomSource.cpp \ > qt/MainThreadQt.cpp \ > qt/StringQt.cpp \ >+ qt/WorkQueueQt.cpp \ > PageAllocationAligned.cpp \ > PageBlock.cpp \ > ParallelJobsGeneric.cpp \ >@@ -209,6 +211,7 @@ SOURCES += \ > TCSystemAlloc.cpp \ > Threading.cpp \ > TypeTraits.cpp \ >+ WorkQueue.cpp \ > WTFThreadData.cpp \ > text/AtomicString.cpp \ > text/CString.cpp \ >diff --git a/Source/WTF/WTF.vcproj/WTF.vcproj b/Source/WTF/WTF.vcproj/WTF.vcproj >index 2190dae1effeae33953327e3cb73e77e6ee46d58..1cc7ae7195d173ab4e6985f85ecc875d5f1c47ca 100644 >--- a/Source/WTF/WTF.vcproj/WTF.vcproj >+++ b/Source/WTF/WTF.vcproj/WTF.vcproj >@@ -343,6 +343,10 @@ > RelativePath="..\wtf\win\OwnPtrWin.cpp" > > > </File> >+ <File >+ RelativePath="..\wtf\win\WorkQueueWin.cpp" >+ > >+ </File> > </Filter> > <Filter > Name="unicode" >@@ -1213,6 +1217,14 @@ > > > </File> > <File >+ RelativePath="..\wtf\WorkQueue.cpp" >+ > >+ </File> >+ <File >+ RelativePath="..\wtf\WorkQueue.h" >+ > >+ </File> >+ <File > RelativePath="..\wtf\WTFThreadData.cpp" > > > </File> >diff --git a/Source/WTF/WTF.xcodeproj/project.pbxproj b/Source/WTF/WTF.xcodeproj/project.pbxproj >index 7720461e264661fc8e9435e90881674bcd1b7658..fcd021ee5cf14d1b52bd2875608b1f7fd87735e3 100644 >--- a/Source/WTF/WTF.xcodeproj/project.pbxproj >+++ b/Source/WTF/WTF.xcodeproj/project.pbxproj >@@ -239,6 +239,9 @@ > A8A4747E151A825B004123FF /* Vector.h in Headers */ = {isa = PBXBuildFile; fileRef = A8A47370151A825B004123FF /* Vector.h */; }; > A8A4747F151A825B004123FF /* VectorTraits.h in Headers */ = {isa = PBXBuildFile; fileRef = A8A47371151A825B004123FF /* VectorTraits.h */; }; > A8A47480151A825B004123FF /* VMTags.h in Headers */ = {isa = PBXBuildFile; fileRef = A8A47372151A825B004123FF /* VMTags.h */; }; >+ BC2E6E8D1141971500A63B1E /* WorkQueue.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BC2E6E7D1141970C00A63B1E /* WorkQueue.cpp */; }; >+ BC2E6E8E1141971500A63B1E /* WorkQueue.h in Headers */ = {isa = PBXBuildFile; fileRef = BC2E6E7E1141970C00A63B1E /* WorkQueue.h */; }; >+ BC0092F8115837A300E0AE2A /* WorkQueueMac.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BC0092F6115837A300E0AE2A /* WorkQueueMac.cpp */; }; > A8A47486151A825B004123FF /* WTFThreadData.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A8A4737A151A825B004123FF /* WTFThreadData.cpp */; }; > A8A47487151A825B004123FF /* WTFThreadData.h in Headers */ = {isa = PBXBuildFile; fileRef = A8A4737B151A825B004123FF /* WTFThreadData.h */; }; > A8A4748C151A8264004123FF /* config.h in Headers */ = {isa = PBXBuildFile; fileRef = A8A4748B151A8264004123FF /* config.h */; }; >@@ -487,6 +490,9 @@ > A8A47370151A825B004123FF /* Vector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Vector.h; sourceTree = "<group>"; }; > A8A47371151A825B004123FF /* VectorTraits.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = VectorTraits.h; sourceTree = "<group>"; }; > A8A47372151A825B004123FF /* VMTags.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = VMTags.h; sourceTree = "<group>"; }; >+ BC2E6E7D1141970C00A63B1E /* WorkQueue.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WorkQueue.cpp; sourceTree = "<group>"; }; >+ BC2E6E7E1141970C00A63B1E /* WorkQueue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WorkQueue.h; sourceTree = "<group>"; }; >+ BC0092F6115837A300E0AE2A /* WorkQueueMac.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WorkQueueMac.cpp; sourceTree = "<group>"; }; > A8A4737A151A825B004123FF /* WTFThreadData.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WTFThreadData.cpp; sourceTree = "<group>"; }; > A8A4737B151A825B004123FF /* WTFThreadData.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WTFThreadData.h; sourceTree = "<group>"; }; > A8A4748B151A8264004123FF /* config.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = config.h; sourceTree = "<group>"; }; >@@ -717,6 +723,8 @@ > A8A47370151A825B004123FF /* Vector.h */, > A8A47371151A825B004123FF /* VectorTraits.h */, > A8A47372151A825B004123FF /* VMTags.h */, >+ BC2E6E7D1141970C00A63B1E /* WorkQueue.cpp */, >+ BC2E6E7E1141970C00A63B1E /* WorkQueue.h */, > A8A4737A151A825B004123FF /* WTFThreadData.cpp */, > A8A4737B151A825B004123FF /* WTFThreadData.h */, > A876DBD7151816E500DADB95 /* Platform.h */, >@@ -756,6 +764,7 @@ > isa = PBXGroup; > children = ( > A8A472C5151A825A004123FF /* MainThreadMac.mm */, >+ BC0092F6115837A300E0AE2A /* WorkQueueMac.cpp */, > ); > path = mac; > sourceTree = "<group>"; >@@ -1037,6 +1046,7 @@ > A8A4747E151A825B004123FF /* Vector.h in Headers */, > A8A4747F151A825B004123FF /* VectorTraits.h in Headers */, > A8A47480151A825B004123FF /* VMTags.h in Headers */, >+ BC2E6E8E1141971500A63B1E /* WorkQueue.h in Headers */, > A8A47487151A825B004123FF /* WTFThreadData.h in Headers */, > A8A4748C151A8264004123FF /* config.h in Headers */, > 143F61201565F0F900DB514A /* RAMSize.h in Headers */, >@@ -1186,6 +1196,8 @@ > A8A47474151A825B004123FF /* URLCharacterTypes.cpp in Sources */, > A8A47477151A825B004123FF /* URLEscape.cpp in Sources */, > A8A4747B151A825B004123FF /* URLSegments.cpp in Sources */, >+ BC2E6E8D1141971500A63B1E /* WorkQueue.cpp in Sources */, >+ BC0092F8115837A300E0AE2A /* WorkQueueMac.cpp in Sources */, > A8A47486151A825B004123FF /* WTFThreadData.cpp in Sources */, > 143F611F1565F0F900DB514A /* RAMSize.cpp in Sources */, > ); >diff --git a/Source/WTF/wtf/CMakeLists.txt b/Source/WTF/wtf/CMakeLists.txt >index 274f04c9749319aef480447916dd22827250868f..be954f04383d9b8f9be4399101ee02febdf42af9 100644 >--- a/Source/WTF/wtf/CMakeLists.txt >+++ b/Source/WTF/wtf/CMakeLists.txt >@@ -102,6 +102,7 @@ SET(WTF_HEADERS > ValueCheck.h > Vector.h > VectorTraits.h >+ WorkQueue.h > WTFThreadData.h > dtoa.h > >@@ -161,6 +162,7 @@ SET(WTF_SOURCES > StringExtras.cpp > Threading.cpp > TypeTraits.cpp >+ WorkQueue.cpp > WTFThreadData.cpp > dtoa.cpp > >diff --git a/Source/WTF/wtf/PlatformEfl.cmake b/Source/WTF/wtf/PlatformEfl.cmake >index 1a13dbba35584e056c49291e387a3225710d1308..fd17f5785edbfd7a27182b4a3dea24f091efd876 100644 >--- a/Source/WTF/wtf/PlatformEfl.cmake >+++ b/Source/WTF/wtf/PlatformEfl.cmake >@@ -1,6 +1,7 @@ > LIST(APPEND WTF_SOURCES > efl/MainThreadEfl.cpp > efl/OwnPtrEfl.cpp >+ efl/WorkQueueEfl.cpp > gobject/GOwnPtr.cpp > gobject/GRefPtr.cpp > >diff --git a/Source/WTF/wtf/PlatformProcessIdentifier.h b/Source/WTF/wtf/PlatformProcessIdentifier.h >new file mode 100644 >index 0000000000000000000000000000000000000000..f7ff53bcd6c9fb4f2977a88c84b769c0d8bfd716 >--- /dev/null >+++ b/Source/WTF/wtf/PlatformProcessIdentifier.h >@@ -0,0 +1,59 @@ >+/* >+ * Copyright (C) 2010 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+ >+#ifndef PlatformProcessIdentifier_h >+#define PlatformProcessIdentifier_h >+ >+#if PLATFORM(QT) >+class QProcess; >+#elif PLATFORM(EFL) >+#include <unistd.h> >+#endif >+ >+namespace WTF { >+ >+#if PLATFORM(MAC) >+typedef pid_t PlatformProcessIdentifier; >+#elif PLATFORM(WIN) >+typedef HANDLE PlatformProcessIdentifier; >+#elif PLATFORM(QT) >+typedef QProcess* PlatformProcessIdentifier; >+#elif PLATFORM(GTK) >+#ifdef G_OS_WIN32 >+typedef void* GPid; >+#else >+typedef int GPid; >+#endif >+typedef GPid PlatformProcessIdentifier; >+#elif PLATFORM(EFL) >+typedef pid_t PlatformProcessIdentifier; >+#endif >+ >+} // namespace WTF >+ >+using WTF::PlatformProcessIdentifier; >+ >+#endif // PlatformProcessIdentifier_h >diff --git a/Source/WTF/wtf/WorkQueue.cpp b/Source/WTF/wtf/WorkQueue.cpp >new file mode 100644 >index 0000000000000000000000000000000000000000..8f5fd14eb4bc9e55201442c328dbaf2f36658f6e >--- /dev/null >+++ b/Source/WTF/wtf/WorkQueue.cpp >@@ -0,0 +1,55 @@ >+/* >+ * Copyright (C) 2010 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#include "config.h" >+#include "WorkQueue.h" >+ >+namespace WTF { >+ >+WorkQueue::WorkQueue(const char* name) >+ : m_isValid(true) >+{ >+ platformInitialize(name); >+} >+ >+WorkQueue::~WorkQueue() >+{ >+#if !ASSERT_DISABLED >+ MutexLocker locker(m_isValidMutex); >+ ASSERT(!m_isValid); >+#endif >+} >+ >+void WorkQueue::invalidate() >+{ >+ { >+ MutexLocker locker(m_isValidMutex); >+ m_isValid = false; >+ } >+ >+ platformInvalidate(); >+} >+ >+} // namespace WTF >diff --git a/Source/WTF/wtf/WorkQueue.h b/Source/WTF/wtf/WorkQueue.h >new file mode 100644 >index 0000000000000000000000000000000000000000..a2b921a0174b9abe8f155570e5173955086788b4 >--- /dev/null >+++ b/Source/WTF/wtf/WorkQueue.h >@@ -0,0 +1,216 @@ >+/* >+ * Copyright (C) 2010 Apple Inc. All rights reserved. >+ * Portions Copyright (c) 2010 Motorola Mobility, Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#ifndef WorkQueue_h >+#define WorkQueue_h >+ >+#if OS(DARWIN) >+#if HAVE(DISPATCH_H) >+#include <dispatch/dispatch.h> >+#endif >+#endif >+ >+#include <wtf/Forward.h> >+#include <wtf/Functional.h> >+#include <wtf/HashMap.h> >+#include <wtf/PassOwnPtr.h> >+#include <wtf/RefCounted.h> >+#include <wtf/Threading.h> >+#include <wtf/Vector.h> >+ >+#if (PLATFORM(QT) && !OS(DARWIN)) || PLATFORM(GTK) || PLATFORM(EFL) >+#include "PlatformProcessIdentifier.h" >+#endif >+ >+#if PLATFORM(QT) && !OS(DARWIN) >+#include <QSocketNotifier> >+class QObject; >+class QThread; >+#elif PLATFORM(GTK) >+#include <wtf/gobject/GRefPtr.h> >+typedef gboolean (*GSourceFunc) (gpointer data); >+#elif PLATFORM(EFL) >+#include <Ecore.h> >+#endif >+ >+namespace WTF { >+ >+class WorkQueue { >+ WTF_MAKE_NONCOPYABLE(WorkQueue); >+ >+public: >+ WTF_EXPORT_PRIVATE explicit WorkQueue(const char* name); >+ WTF_EXPORT_PRIVATE ~WorkQueue(); >+ >+ // Will dispatch the given function to run as soon as possible. >+ WTF_EXPORT_PRIVATE void dispatch(const Function<void()>&); >+ >+ // Will dispatch the given function after the given delay (in seconds). >+ WTF_EXPORT_PRIVATE void dispatchAfterDelay(const Function<void()>&, double delay); >+ >+ WTF_EXPORT_PRIVATE void invalidate(); >+ >+#if OS(DARWIN) >+ enum MachPortEventType { >+ // Fired when there is data on the given receive right. >+ MachPortDataAvailable, >+ >+ // Fired when the receive right for this send right has been destroyed. >+ MachPortDeadNameNotification >+ }; >+ >+ // Will execute the given function whenever the given mach port event fires. >+ // Note that this will adopt the mach port and destroy it when the work queue is invalidated. >+ WTF_EXPORT_PRIVATE void registerMachPortEventHandler(mach_port_t, MachPortEventType, const Function<void()>&); >+ WTF_EXPORT_PRIVATE void unregisterMachPortEventHandler(mach_port_t); >+#elif PLATFORM(WIN) >+ void registerHandle(HANDLE, const Function<void()>&); >+ void unregisterAndCloseHandle(HANDLE); >+#elif PLATFORM(QT) >+ QSocketNotifier* registerSocketEventHandler(int, QSocketNotifier::Type, const Function<void()>&); >+ void dispatchOnTermination(PlatformProcessIdentifier, const Function<void()>&); >+#elif PLATFORM(GTK) >+ void registerEventSourceHandler(int, int, const Function<void()>&); >+ void unregisterEventSourceHandler(int); >+ void dispatchOnTermination(PlatformProcessIdentifier, const Function<void()>&); >+#elif PLATFORM(EFL) >+ void registerSocketEventHandler(int, const Function<void()>&); >+ void unregisterSocketEventHandler(int); >+#endif >+ >+private: >+ // FIXME: Use an atomic boolean here instead. >+ Mutex m_isValidMutex; >+ bool m_isValid; >+ >+ void platformInitialize(const char* name); >+ void platformInvalidate(); >+ >+#if OS(DARWIN) >+#if HAVE(DISPATCH_H) >+ static void executeFunction(void*); >+ Mutex m_eventSourcesMutex; >+ class EventSource; >+ HashMap<mach_port_t, EventSource*> m_eventSources; >+ dispatch_queue_t m_dispatchQueue; >+#endif >+#elif PLATFORM(WIN) >+ class WorkItemWin : public ThreadSafeRefCounted<WorkItemWin> { >+ public: >+ static PassRefPtr<WorkItemWin> create(const Function<void()>&, WorkQueue*); >+ virtual ~WorkItemWin(); >+ >+ Function<void()>& function() { return m_function; } >+ WorkQueue* queue() const { return m_queue; } >+ >+ protected: >+ WorkItemWin(const Function<void()>&, WorkQueue*); >+ >+ private: >+ Function<void()> m_function; >+ WorkQueue* m_queue; >+ }; >+ >+ class HandleWorkItem : public WorkItemWin { >+ public: >+ static PassRefPtr<HandleWorkItem> createByAdoptingHandle(HANDLE, const Function<void()>&, WorkQueue*); >+ virtual ~HandleWorkItem(); >+ >+ void setWaitHandle(HANDLE waitHandle) { m_waitHandle = waitHandle; } >+ HANDLE waitHandle() const { return m_waitHandle; } >+ >+ private: >+ HandleWorkItem(HANDLE, const Function<void()>&, WorkQueue*); >+ >+ HANDLE m_handle; >+ HANDLE m_waitHandle; >+ }; >+ >+ static void CALLBACK handleCallback(void* context, BOOLEAN timerOrWaitFired); >+ static void CALLBACK timerCallback(void* context, BOOLEAN timerOrWaitFired); >+ static DWORD WINAPI workThreadCallback(void* context); >+ >+ bool tryRegisterAsWorkThread(); >+ void unregisterAsWorkThread(); >+ void performWorkOnRegisteredWorkThread(); >+ >+ static void unregisterWaitAndDestroyItemSoon(PassRefPtr<HandleWorkItem>); >+ static DWORD WINAPI unregisterWaitAndDestroyItemCallback(void* context); >+ >+ volatile LONG m_isWorkThreadRegistered; >+ >+ Mutex m_workItemQueueLock; >+ Vector<RefPtr<WorkItemWin> > m_workItemQueue; >+ >+ Mutex m_handlesLock; >+ HashMap<HANDLE, RefPtr<HandleWorkItem> > m_handles; >+ >+ HANDLE m_timerQueue; >+#elif PLATFORM(QT) >+ class WorkItemQt; >+ QThread* m_workThread; >+ friend class WorkItemQt; >+#elif PLATFORM(GTK) >+ static void startWorkQueueThread(WorkQueue*); >+ void workQueueThreadBody(); >+ void dispatchOnSource(GSource*, const Function<void()>&, GSourceFunc); >+ >+ ThreadIdentifier m_workQueueThread; >+ GRefPtr<GMainContext> m_eventContext; >+ Mutex m_eventLoopLock; >+ GRefPtr<GMainLoop> m_eventLoop; >+ Mutex m_eventSourcesLock; >+ class EventSource; >+ HashMap<int, Vector<EventSource*> > m_eventSources; >+ typedef HashMap<int, Vector<EventSource*> >::iterator EventSourceIterator; >+#elif PLATFORM(EFL) >+ fd_set m_fileDescriptorSet; >+ int m_maxFileDescriptor; >+ int m_readFromPipeDescriptor; >+ int m_writeToPipeDescriptor; >+ bool m_threadLoop; >+ >+ Vector<Function<void()> > m_workItemQueue; >+ Mutex m_workItemQueueLock; >+ >+ int m_socketDescriptor; >+ Function<void()> m_socketEventHandler; >+ >+ HashMap<int, OwnPtr<Ecore_Timer> > m_timers; >+ >+ void sendMessageToThread(const char*); >+ static void* workQueueThread(WorkQueue*); >+ void performWork(); >+ void performFileDescriptorWork(); >+ static bool timerFired(void*); >+#endif >+}; >+ >+} // namespace WTF >+ >+using WTF::WorkQueue; >+ >+#endif // WorkQueue_h >diff --git a/Source/WTF/wtf/efl/WorkQueueEfl.cpp b/Source/WTF/wtf/efl/WorkQueueEfl.cpp >new file mode 100644 >index 0000000000000000000000000000000000000000..3a39ba9ed9b1270fe7df9e6ce685db473a5f58a7 >--- /dev/null >+++ b/Source/WTF/wtf/efl/WorkQueueEfl.cpp >@@ -0,0 +1,173 @@ >+/* >+ Copyright (C) 2012 Samsung Electronics >+ >+ This library is free software; you can redistribute it and/or >+ modify it under the terms of the GNU Library General Public >+ License as published by the Free Software Foundation; either >+ version 2 of the License, or (at your option) any later version. >+ >+ This library is distributed in the hope that it will be useful, >+ but WITHOUT ANY WARRANTY; without even the implied warranty of >+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU >+ Library General Public License for more details. >+ >+ You should have received a copy of the GNU Library General Public License >+ along with this library; see the file COPYING.LIB. If not, write to >+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, >+ Boston, MA 02110-1301, USA. >+ */ >+ >+#include "config.h" >+#include "WorkQueue.h" >+ >+#include <wtf/Assertions.h> >+ >+class TimerWorkItem { >+public: >+ TimerWorkItem(int timerID, const Function<void()>& function, WorkQueue* queue) >+ : m_function(function) >+ , m_queue(queue) >+ , m_timerID(timerID) >+ { >+ } >+ ~TimerWorkItem() { } >+ >+ Function<void()> function() const { return m_function; } >+ WorkQueue* queue() const { return m_queue; } >+ >+ int timerID() const { return m_timerID; } >+ >+private: >+ Function<void()> m_function; >+ WorkQueue* m_queue; >+ int m_timerID; >+}; >+ >+static const int invalidSocketDescriptor = -1; >+static const int threadMessageSize = 1; >+static const char finishThreadMessage[] = "F"; >+static const char wakupThreadMessage[] = "W"; >+ >+void WorkQueue::platformInitialize(const char* name) >+{ >+ int fds[2]; >+ if (pipe(fds)) >+ ASSERT_NOT_REACHED(); >+ >+ m_readFromPipeDescriptor = fds[0]; >+ m_writeToPipeDescriptor = fds[1]; >+ FD_ZERO(&m_fileDescriptorSet); >+ FD_SET(m_readFromPipeDescriptor, &m_fileDescriptorSet); >+ m_maxFileDescriptor = m_readFromPipeDescriptor; >+ >+ m_socketDescriptor = invalidSocketDescriptor; >+ >+ m_threadLoop = true; >+ createThread(reinterpret_cast<WTF::ThreadFunction>(&WorkQueue::workQueueThread), this, name); >+} >+ >+void WorkQueue::platformInvalidate() >+{ >+ sendMessageToThread(finishThreadMessage); >+} >+ >+void WorkQueue::performWork() >+{ >+ m_workItemQueueLock.lock(); >+ >+ while (!m_workItemQueue.isEmpty()) { >+ Vector<Function<void()> > workItemQueue; >+ m_workItemQueue.swap(workItemQueue); >+ >+ m_workItemQueueLock.unlock(); >+ for (size_t i = 0; i < workItemQueue.size(); ++i) >+ workItemQueue[i](); >+ m_workItemQueueLock.lock(); >+ } >+ m_workItemQueueLock.unlock(); >+} >+ >+void WorkQueue::performFileDescriptorWork() >+{ >+ fd_set readFileDescriptorSet = m_fileDescriptorSet; >+ >+ if (select(m_maxFileDescriptor + 1, &readFileDescriptorSet, 0, 0, 0) >= 0) { >+ if (FD_ISSET(m_readFromPipeDescriptor, &readFileDescriptorSet)) { >+ char readBuf[threadMessageSize]; >+ if (read(m_readFromPipeDescriptor, readBuf, threadMessageSize) == -1) >+ LOG_ERROR("Failed to read from WorkQueueThread pipe"); >+ if (!strncmp(readBuf, finishThreadMessage, threadMessageSize)) >+ m_threadLoop = false; >+ } >+ >+ if (m_socketDescriptor != invalidSocketDescriptor && FD_ISSET(m_socketDescriptor, &readFileDescriptorSet)) >+ m_socketEventHandler(); >+ } >+} >+ >+void WorkQueue::sendMessageToThread(const char* message) >+{ >+ if (write(m_writeToPipeDescriptor, message, threadMessageSize) == -1) >+ LOG_ERROR("Failed to wake up WorkQueue Thread"); >+} >+ >+void* WorkQueue::workQueueThread(WorkQueue* workQueue) >+{ >+ while (workQueue->m_threadLoop) { >+ workQueue->performWork(); >+ workQueue->performFileDescriptorWork(); >+ } >+ >+ close(workQueue->m_readFromPipeDescriptor); >+ close(workQueue->m_writeToPipeDescriptor); >+ >+ return 0; >+} >+ >+void WorkQueue::registerSocketEventHandler(int fileDescriptor, const Function<void()>& function) >+{ >+ if (m_socketDescriptor != invalidSocketDescriptor) >+ LOG_ERROR("%d is already registerd.", fileDescriptor); >+ >+ m_socketDescriptor = fileDescriptor; >+ m_socketEventHandler = function; >+ >+ if (fileDescriptor > m_maxFileDescriptor) >+ m_maxFileDescriptor = fileDescriptor; >+ FD_SET(fileDescriptor, &m_fileDescriptorSet); >+} >+ >+void WorkQueue::unregisterSocketEventHandler(int fileDescriptor) >+{ >+ m_socketDescriptor = invalidSocketDescriptor; >+ >+ if (fileDescriptor == m_maxFileDescriptor) >+ m_maxFileDescriptor = m_readFromPipeDescriptor; >+ FD_CLR(fileDescriptor, &m_fileDescriptorSet); >+} >+ >+void WorkQueue::dispatch(const Function<void()>& function) >+{ >+ MutexLocker locker(m_workItemQueueLock); >+ m_workItemQueue.append(function); >+ sendMessageToThread(wakupThreadMessage); >+} >+ >+bool WorkQueue::timerFired(void* data) >+{ >+ TimerWorkItem* item = static_cast<TimerWorkItem*>(data); >+ if (item && item->queue()->m_isValid) { >+ item->queue()->dispatch(item->function()); >+ item->queue()->m_timers.take(item->timerID()); >+ delete item; >+ } >+ >+ return ECORE_CALLBACK_CANCEL; >+} >+ >+void WorkQueue::dispatchAfterDelay(const Function<void()>& function, double delay) >+{ >+ static int timerId = 0; >+ m_timers.set(timerId, adoptPtr(ecore_timer_add(delay, reinterpret_cast<Ecore_Task_Cb>(timerFired), new TimerWorkItem(timerId, function, this)))); >+ timerId++; >+} >diff --git a/Source/WTF/wtf/gtk/WorkQueueGtk.cpp b/Source/WTF/wtf/gtk/WorkQueueGtk.cpp >new file mode 100644 >index 0000000000000000000000000000000000000000..b91f6351d73b0210eeac6696735887ef8ea6a6d4 >--- /dev/null >+++ b/Source/WTF/wtf/gtk/WorkQueueGtk.cpp >@@ -0,0 +1,229 @@ >+/* >+ * Copyright (C) 2011 Igalia S.L. >+ * Copyright (C) 2010 Apple Inc. All rights reserved. >+ * Portions Copyright (c) 2010 Motorola Mobility, Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#include "config.h" >+#include "WorkQueue.h" >+ >+#include <gio/gio.h> >+#include <glib.h> >+#include <wtf/gobject/GRefPtr.h> >+ >+// WorkQueue::EventSource >+class WorkQueue::EventSource { >+public: >+ EventSource(const Function<void()>& function, WorkQueue* workQueue, GCancellable* cancellable) >+ : m_function(function) >+ , m_workQueue(workQueue) >+ , m_cancellable(cancellable) >+ { >+ } >+ >+ void cancel() >+ { >+ if (!m_cancellable) >+ return; >+ g_cancellable_cancel(m_cancellable); >+ } >+ >+ static void executeEventSource(EventSource* eventSource) >+ { >+ ASSERT(eventSource); >+ WorkQueue* queue = eventSource->m_workQueue; >+ { >+ MutexLocker locker(queue->m_isValidMutex); >+ if (!queue->m_isValid) >+ return; >+ } >+ >+ eventSource->m_function(); >+ } >+ >+ static gboolean performWorkOnce(EventSource* eventSource) >+ { >+ executeEventSource(eventSource); >+ return FALSE; >+ } >+ >+ static gboolean performWork(GSocket* socket, GIOCondition condition, EventSource* eventSource) >+ { >+ if (!(condition & G_IO_IN) && !(condition & G_IO_HUP) && !(condition & G_IO_ERR)) { >+ // EventSource has been cancelled, return FALSE to destroy the source. >+ return FALSE; >+ } >+ >+ executeEventSource(eventSource); >+ return TRUE; >+ } >+ >+ static gboolean performWorkOnTermination(GPid, gint, EventSource* eventSource) >+ { >+ executeEventSource(eventSource); >+ return FALSE; >+ } >+ >+ static void deleteEventSource(EventSource* eventSource) >+ { >+ ASSERT(eventSource); >+ delete eventSource; >+ } >+ >+public: >+ Function<void()> m_function; >+ WorkQueue* m_workQueue; >+ GCancellable* m_cancellable; >+}; >+ >+// WorkQueue >+static const size_t kVisualStudioThreadNameLimit = 31; >+ >+void WorkQueue::platformInitialize(const char* name) >+{ >+ m_eventContext = adoptGRef(g_main_context_new()); >+ ASSERT(m_eventContext); >+ m_eventLoop = adoptGRef(g_main_loop_new(m_eventContext.get(), FALSE)); >+ ASSERT(m_eventLoop); >+ >+ // This name can be com.apple.WebKit.ProcessLauncher or com.apple.CoreIPC.ReceiveQueue. >+ // We are using those names for the thread name, but both are longer than 31 characters, >+ // which is the limit of Visual Studio for thread names. >+ // When log is enabled createThread() will assert instead of truncate the name, so we need >+ // to make sure we don't use a name longer than 31 characters. >+ const char* threadName = g_strrstr(name, "."); >+ if (threadName) >+ threadName++; >+ else >+ threadName = name; >+ if (strlen(threadName) > kVisualStudioThreadNameLimit) >+ threadName += strlen(threadName) - kVisualStudioThreadNameLimit; >+ >+ m_workQueueThread = createThread(reinterpret_cast<WTF::ThreadFunction>(&WorkQueue::startWorkQueueThread), this, threadName); >+} >+ >+void WorkQueue::platformInvalidate() >+{ >+ MutexLocker locker(m_eventLoopLock); >+ >+ if (m_eventLoop) { >+ if (g_main_loop_is_running(m_eventLoop.get())) >+ g_main_loop_quit(m_eventLoop.get()); >+ m_eventLoop.clear(); >+ } >+ >+ m_eventContext.clear(); >+} >+ >+void WorkQueue::startWorkQueueThread(WorkQueue* workQueue) >+{ >+ workQueue->workQueueThreadBody(); >+} >+ >+void WorkQueue::workQueueThreadBody() >+{ >+ g_main_loop_run(m_eventLoop.get()); >+} >+ >+void WorkQueue::registerEventSourceHandler(int fileDescriptor, int condition, const Function<void()>& function) >+{ >+ GRefPtr<GSocket> socket = adoptGRef(g_socket_new_from_fd(fileDescriptor, 0)); >+ ASSERT(socket); >+ GRefPtr<GCancellable> cancellable = adoptGRef(g_cancellable_new()); >+ GRefPtr<GSource> dispatchSource = adoptGRef(g_socket_create_source(socket.get(), static_cast<GIOCondition>(condition), cancellable.get())); >+ ASSERT(dispatchSource); >+ EventSource* eventSource = new EventSource(function, this, cancellable.get()); >+ ASSERT(eventSource); >+ >+ g_source_set_callback(dispatchSource.get(), reinterpret_cast<GSourceFunc>(&WorkQueue::EventSource::performWork), >+ eventSource, reinterpret_cast<GDestroyNotify>(&WorkQueue::EventSource::deleteEventSource)); >+ >+ // Set up the event sources under the mutex since this is shared across multiple threads. >+ { >+ MutexLocker locker(m_eventSourcesLock); >+ Vector<EventSource*> sources; >+ EventSourceIterator it = m_eventSources.find(fileDescriptor); >+ if (it != m_eventSources.end()) >+ sources = it->second; >+ >+ sources.append(eventSource); >+ m_eventSources.set(fileDescriptor, sources); >+ } >+ >+ g_source_attach(dispatchSource.get(), m_eventContext.get()); >+} >+ >+void WorkQueue::unregisterEventSourceHandler(int fileDescriptor) >+{ >+ ASSERT(fileDescriptor); >+ >+ MutexLocker locker(m_eventSourcesLock); >+ >+ EventSourceIterator it = m_eventSources.find(fileDescriptor); >+ ASSERT(it != m_eventSources.end()); >+ ASSERT(m_eventSources.contains(fileDescriptor)); >+ >+ if (it != m_eventSources.end()) { >+ Vector<EventSource*> sources = it->second; >+ for (unsigned i = 0; i < sources.size(); i++) >+ sources[i]->cancel(); >+ >+ m_eventSources.remove(it); >+ } >+} >+ >+void WorkQueue::dispatchOnSource(GSource* dispatchSource, const Function<void()>& function, GSourceFunc sourceCallback) >+{ >+ EventSource* eventSource = new EventSource(function, this, 0); >+ >+ g_source_set_callback(dispatchSource, sourceCallback, eventSource, >+ reinterpret_cast<GDestroyNotify>(&WorkQueue::EventSource::deleteEventSource)); >+ >+ g_source_attach(dispatchSource, m_eventContext.get()); >+} >+ >+void WorkQueue::dispatch(const Function<void()>& function) >+{ >+ GRefPtr<GSource> dispatchSource = adoptGRef(g_idle_source_new()); >+ ASSERT(dispatchSource); >+ g_source_set_priority(dispatchSource.get(), G_PRIORITY_DEFAULT); >+ >+ dispatchOnSource(dispatchSource.get(), function, reinterpret_cast<GSourceFunc>(&WorkQueue::EventSource::performWorkOnce)); >+} >+ >+void WorkQueue::dispatchAfterDelay(const Function<void()>& function, double delay) >+{ >+ GRefPtr<GSource> dispatchSource = adoptGRef(g_timeout_source_new(static_cast<guint>(delay * 1000))); >+ ASSERT(dispatchSource); >+ >+ dispatchOnSource(dispatchSource.get(), function, reinterpret_cast<GSourceFunc>(&WorkQueue::EventSource::performWorkOnce)); >+} >+ >+void WorkQueue::dispatchOnTermination(PlatformProcessIdentifier process, const Function<void()>& function) >+{ >+ GRefPtr<GSource> dispatchSource = adoptGRef(g_child_watch_source_new(process)); >+ ASSERT(dispatchSource); >+ >+ dispatchOnSource(dispatchSource.get(), function, reinterpret_cast<GSourceFunc>(&WorkQueue::EventSource::performWorkOnTermination)); >+} >diff --git a/Source/WTF/wtf/mac/WorkQueueMac.cpp b/Source/WTF/wtf/mac/WorkQueueMac.cpp >new file mode 100644 >index 0000000000000000000000000000000000000000..4aee7b24839b0a323ba2bab890959ca3dbc733d5 >--- /dev/null >+++ b/Source/WTF/wtf/mac/WorkQueueMac.cpp >@@ -0,0 +1,182 @@ >+/* >+ * Copyright (C) 2010 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#include "config.h" >+#include "WorkQueue.h" >+ >+#include <mach/mach_init.h> >+#include <mach/mach_port.h> >+#include <wtf/PassOwnPtr.h> >+ >+namespace WTF { >+ >+void WorkQueue::executeFunction(void* context) >+{ >+ WorkQueue* queue = static_cast<WorkQueue*>(dispatch_get_context(dispatch_get_current_queue())); >+ OwnPtr<Function<void()> > function = adoptPtr(static_cast<Function<void()>*>(context)); >+ >+ { >+ MutexLocker locker(queue->m_isValidMutex); >+ if (!queue->m_isValid) >+ return; >+ } >+ >+ (*function)(); >+} >+ >+void WorkQueue::dispatch(const Function<void()>& function) >+{ >+ dispatch_async_f(m_dispatchQueue, new Function<void()>(function), executeFunction); >+} >+ >+void WorkQueue::dispatchAfterDelay(const Function<void()>& function, double delay) >+{ >+ dispatch_time_t delayTime = dispatch_time(DISPATCH_TIME_NOW, delay * NSEC_PER_SEC); >+ >+ dispatch_after_f(delayTime, m_dispatchQueue, new Function<void()>(function), executeFunction); >+} >+ >+class WorkQueue::EventSource { >+public: >+ EventSource(MachPortEventType eventType, dispatch_source_t dispatchSource, const Function<void()>& function) >+ : m_eventType(eventType) >+ , m_dispatchSource(dispatchSource) >+ , m_function(function) >+ { >+ } >+ >+ dispatch_source_t dispatchSource() const { return m_dispatchSource; } >+ >+ static void eventHandler(void* source) >+ { >+ EventSource* eventSource = static_cast<EventSource*>(source); >+ >+ eventSource->m_function(); >+ } >+ >+ static void cancelHandler(void* source) >+ { >+ EventSource* eventSource = static_cast<EventSource*>(source); >+ >+ mach_port_t machPort = dispatch_source_get_handle(eventSource->m_dispatchSource); >+ >+ switch (eventSource->m_eventType) { >+ case MachPortDataAvailable: >+ // Release our receive right. >+ mach_port_mod_refs(mach_task_self(), machPort, MACH_PORT_RIGHT_RECEIVE, -1); >+ break; >+ case MachPortDeadNameNotification: >+ // Release our send right. >+ mach_port_deallocate(mach_task_self(), machPort); >+ break; >+ } >+ } >+ >+ static void finalizeHandler(void* source) >+ { >+ EventSource* eventSource = static_cast<EventSource*>(source); >+ >+ delete eventSource; >+ } >+ >+private: >+ MachPortEventType m_eventType; >+ >+ // This is a weak reference, since m_dispatchSource references the event source. >+ dispatch_source_t m_dispatchSource; >+ >+ Function<void()> m_function; >+}; >+ >+void WorkQueue::registerMachPortEventHandler(mach_port_t machPort, MachPortEventType eventType, const Function<void()>& function) >+{ >+ dispatch_source_type_t sourceType = 0; >+ switch (eventType) { >+ case MachPortDataAvailable: >+ sourceType = DISPATCH_SOURCE_TYPE_MACH_RECV; >+ break; >+ case MachPortDeadNameNotification: >+ sourceType = DISPATCH_SOURCE_TYPE_MACH_SEND; >+ break; >+ } >+ >+ dispatch_source_t dispatchSource = dispatch_source_create(sourceType, machPort, 0, m_dispatchQueue); >+ >+ EventSource* eventSource = new EventSource(eventType, dispatchSource, function); >+ dispatch_set_context(dispatchSource, eventSource); >+ >+ dispatch_source_set_event_handler_f(dispatchSource, &EventSource::eventHandler); >+ dispatch_source_set_cancel_handler_f(dispatchSource, &EventSource::cancelHandler); >+ dispatch_set_finalizer_f(dispatchSource, &EventSource::finalizeHandler); >+ >+ // Add the source to our set of sources. >+ { >+ MutexLocker locker(m_eventSourcesMutex); >+ >+ ASSERT(!m_eventSources.contains(machPort)); >+ >+ m_eventSources.set(machPort, eventSource); >+ >+ // And start it! >+ dispatch_resume(dispatchSource); >+ } >+} >+ >+void WorkQueue::unregisterMachPortEventHandler(mach_port_t machPort) >+{ >+ ASSERT(machPort); >+ >+ MutexLocker locker(m_eventSourcesMutex); >+ >+ HashMap<mach_port_t, EventSource*>::iterator it = m_eventSources.find(machPort); >+ ASSERT(it != m_eventSources.end()); >+ >+ ASSERT(m_eventSources.contains(machPort)); >+ >+ EventSource* eventSource = it->second; >+ // Cancel and release the source. It will be deleted in its finalize handler. >+ dispatch_source_cancel(eventSource->dispatchSource()); >+ dispatch_release(eventSource->dispatchSource()); >+ >+ m_eventSources.remove(it); >+} >+ >+void WorkQueue::platformInitialize(const char* name) >+{ >+ m_dispatchQueue = dispatch_queue_create(name, 0); >+ dispatch_set_context(m_dispatchQueue, this); >+} >+ >+void WorkQueue::platformInvalidate() >+{ >+#if !ASSERT_DISABLED >+ MutexLocker locker(m_eventSourcesMutex); >+ ASSERT(m_eventSources.isEmpty()); >+#endif >+ >+ dispatch_release(m_dispatchQueue); >+} >+ >+} // namespace WTF >diff --git a/Source/WTF/wtf/qt/WorkQueueQt.cpp b/Source/WTF/wtf/qt/WorkQueueQt.cpp >new file mode 100644 >index 0000000000000000000000000000000000000000..05091ffda73960c60c40f1f4ceee952c61c3d66b >--- /dev/null >+++ b/Source/WTF/wtf/qt/WorkQueueQt.cpp >@@ -0,0 +1,132 @@ >+/* >+ * Copyright (C) 2010 Apple Inc. All rights reserved. >+ * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies) >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#include "config.h" >+#include "WorkQueue.h" >+ >+#include <QObject> >+#include <QProcess> >+#include <QThread> >+#include <wtf/Threading.h> >+ >+namespace WTF { >+ >+class WorkQueue::WorkItemQt : public QObject { >+ Q_OBJECT >+public: >+ WorkItemQt(WorkQueue* workQueue, const Function<void()>& function) >+ : m_queue(workQueue) >+ , m_source(0) >+ , m_signal(0) >+ , m_function(function) >+ { >+ } >+ >+ WorkItemQt(WorkQueue* workQueue, QObject* source, const char* signal, const Function<void()>& function) >+ : m_queue(workQueue) >+ , m_source(source) >+ , m_signal(signal) >+ , m_function(function) >+ { >+ connect(m_source, m_signal, SLOT(execute()), Qt::QueuedConnection); >+ } >+ >+ ~WorkItemQt() >+ { >+ } >+ >+ Q_SLOT void execute() >+ { >+ if (m_queue->m_isValid) >+ m_function(); >+ } >+ >+ Q_SLOT void executeAndDelete() >+ { >+ execute(); >+ delete this; >+ } >+ >+ virtual void timerEvent(QTimerEvent*) >+ { >+ executeAndDelete(); >+ } >+ >+ WorkQueue* m_queue; >+ QObject* m_source; >+ const char* m_signal; >+ Function<void()> m_function; >+}; >+ >+QSocketNotifier* WorkQueue::registerSocketEventHandler(int socketDescriptor, QSocketNotifier::Type type, const Function<void()>& function) >+{ >+ ASSERT(m_workThread); >+ >+ QSocketNotifier* notifier = new QSocketNotifier(socketDescriptor, type, 0); >+ notifier->setEnabled(false); >+ notifier->moveToThread(m_workThread); >+ WorkQueue::WorkItemQt* itemQt = new WorkQueue::WorkItemQt(this, notifier, SIGNAL(activated(int)), function); >+ itemQt->moveToThread(m_workThread); >+ notifier->setEnabled(true); >+ return notifier; >+} >+ >+void WorkQueue::platformInitialize(const char*) >+{ >+ m_workThread = new QThread(); >+ m_workThread->start(); >+} >+ >+void WorkQueue::platformInvalidate() >+{ >+ m_workThread->exit(); >+ m_workThread->wait(); >+ delete m_workThread; >+} >+ >+void WorkQueue::dispatch(const Function<void()>& function) >+{ >+ WorkQueue::WorkItemQt* itemQt = new WorkQueue::WorkItemQt(this, function); >+ itemQt->moveToThread(m_workThread); >+ QMetaObject::invokeMethod(itemQt, "executeAndDelete", Qt::QueuedConnection); >+} >+ >+void WorkQueue::dispatchAfterDelay(const Function<void()>& function, double delayInSecond) >+{ >+ WorkQueue::WorkItemQt* itemQt = new WorkQueue::WorkItemQt(this, function); >+ itemQt->startTimer(static_cast<int>(delayInSecond * 1000)); >+ itemQt->moveToThread(m_workThread); >+} >+ >+void WorkQueue::dispatchOnTermination(PlatformProcessIdentifier process, const Function<void()>& function) >+{ >+ WorkQueue::WorkItemQt* itemQt = new WorkQueue::WorkItemQt(this, process, SIGNAL(finished(int, QProcess::ExitStatus)), function); >+ itemQt->moveToThread(m_workThread); >+} >+ >+} // namespace WTF >+ >+#include "WorkQueueQt.moc" >diff --git a/Source/WTF/wtf/win/WorkQueueWin.cpp b/Source/WTF/wtf/win/WorkQueueWin.cpp >new file mode 100644 >index 0000000000000000000000000000000000000000..6f7605713bf93602cd35146ffa4da58b8c6e52f3 >--- /dev/null >+++ b/Source/WTF/wtf/win/WorkQueueWin.cpp >@@ -0,0 +1,294 @@ >+/* >+ * Copyright (C) 2010 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >+ * THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#include "config.h" >+#include "WorkQueue.h" >+ >+#include <wtf/Threading.h> >+ >+namespace WTF { >+ >+inline WorkQueue::WorkItemWin::WorkItemWin(const Function<void()>& function, WorkQueue* queue) >+ : m_function(function) >+ , m_queue(queue) >+{ >+} >+ >+PassRefPtr<WorkQueue::WorkItemWin> WorkQueue::WorkItemWin::create(const Function<void()>& function, WorkQueue* queue) >+{ >+ return adoptRef(new WorkItemWin(function, queue)); >+} >+ >+WorkQueue::WorkItemWin::~WorkItemWin() >+{ >+} >+ >+inline WorkQueue::HandleWorkItem::HandleWorkItem(HANDLE handle, const Function<void()>& function, WorkQueue* queue) >+ : WorkItemWin(function, queue) >+ , m_handle(handle) >+ , m_waitHandle(0) >+{ >+ ASSERT_ARG(handle, handle); >+} >+ >+PassRefPtr<WorkQueue::HandleWorkItem> WorkQueue::HandleWorkItem::createByAdoptingHandle(HANDLE handle, const Function<void()>& function, WorkQueue* queue) >+{ >+ return adoptRef(new HandleWorkItem(handle, function, queue)); >+} >+ >+WorkQueue::HandleWorkItem::~HandleWorkItem() >+{ >+ ::CloseHandle(m_handle); >+} >+ >+void WorkQueue::handleCallback(void* context, BOOLEAN timerOrWaitFired) >+{ >+ ASSERT_ARG(context, context); >+ ASSERT_ARG(timerOrWaitFired, !timerOrWaitFired); >+ >+ WorkItemWin* item = static_cast<WorkItemWin*>(context); >+ WorkQueue* queue = item->queue(); >+ >+ { >+ MutexLocker lock(queue->m_workItemQueueLock); >+ queue->m_workItemQueue.append(item); >+ >+ // If no other thread is performing work, we can do it on this thread. >+ if (!queue->tryRegisterAsWorkThread()) { >+ // Some other thread is performing work. Since we hold the queue lock, we can be sure >+ // that the work thread is not exiting due to an empty queue and will process the work >+ // item we just added to it. If we weren't holding the lock we'd have to signal >+ // m_performWorkEvent to make sure the work item got picked up. >+ return; >+ } >+ } >+ >+ queue->performWorkOnRegisteredWorkThread(); >+} >+ >+void WorkQueue::registerHandle(HANDLE handle, const Function<void()>& function) >+{ >+ RefPtr<HandleWorkItem> handleItem = HandleWorkItem::createByAdoptingHandle(handle, function, this); >+ >+ { >+ MutexLocker lock(m_handlesLock); >+ ASSERT_ARG(handle, !m_handles.contains(handle)); >+ m_handles.set(handle, handleItem); >+ } >+ >+ HANDLE waitHandle; >+ if (!::RegisterWaitForSingleObject(&waitHandle, handle, handleCallback, handleItem.get(), INFINITE, WT_EXECUTEDEFAULT)) { >+ DWORD error = ::GetLastError(); >+ ASSERT_NOT_REACHED(); >+ } >+ handleItem->setWaitHandle(waitHandle); >+} >+ >+void WorkQueue::unregisterAndCloseHandle(HANDLE handle) >+{ >+ RefPtr<HandleWorkItem> item; >+ { >+ MutexLocker locker(m_handlesLock); >+ ASSERT_ARG(handle, m_handles.contains(handle)); >+ item = m_handles.take(handle); >+ } >+ >+ unregisterWaitAndDestroyItemSoon(item.release()); >+} >+ >+DWORD WorkQueue::workThreadCallback(void* context) >+{ >+ ASSERT_ARG(context, context); >+ >+ WorkQueue* queue = static_cast<WorkQueue*>(context); >+ >+ if (!queue->tryRegisterAsWorkThread()) >+ return 0; >+ >+ queue->performWorkOnRegisteredWorkThread(); >+ return 0; >+} >+ >+void WorkQueue::performWorkOnRegisteredWorkThread() >+{ >+ ASSERT(m_isWorkThreadRegistered); >+ >+ bool isValid = true; >+ >+ m_workItemQueueLock.lock(); >+ >+ while (isValid && !m_workItemQueue.isEmpty()) { >+ Vector<RefPtr<WorkItemWin> > workItemQueue; >+ m_workItemQueue.swap(workItemQueue); >+ >+ // Allow more work to be scheduled while we're not using the queue directly. >+ m_workItemQueueLock.unlock(); >+ for (size_t i = 0; i < workItemQueue.size(); ++i) { >+ MutexLocker locker(m_isValidMutex); >+ isValid = m_isValid; >+ if (!isValid) >+ break; >+ workItemQueue[i]->function()(); >+ } >+ m_workItemQueueLock.lock(); >+ } >+ >+ // One invariant we maintain is that any work scheduled while a work thread is registered will >+ // be handled by that work thread. Unregister as the work thread while the queue lock is still >+ // held so that no work can be scheduled while we're still registered. >+ unregisterAsWorkThread(); >+ >+ m_workItemQueueLock.unlock(); >+} >+ >+void WorkQueue::platformInitialize(const char* name) >+{ >+ m_isWorkThreadRegistered = 0; >+ m_timerQueue = ::CreateTimerQueue(); >+ ASSERT_WITH_MESSAGE(m_timerQueue, "::CreateTimerQueue failed with error %lu", ::GetLastError()); >+} >+ >+bool WorkQueue::tryRegisterAsWorkThread() >+{ >+ LONG result = ::InterlockedCompareExchange(&m_isWorkThreadRegistered, 1, 0); >+ ASSERT(!result || result == 1); >+ return !result; >+} >+ >+void WorkQueue::unregisterAsWorkThread() >+{ >+ LONG result = ::InterlockedCompareExchange(&m_isWorkThreadRegistered, 0, 1); >+ ASSERT_UNUSED(result, result == 1); >+} >+ >+void WorkQueue::platformInvalidate() >+{ >+#if !ASSERT_DISABLED >+ MutexLocker lock(m_handlesLock); >+ ASSERT(m_handles.isEmpty()); >+#endif >+ >+ // FIXME: We need to ensure that any timer-queue timers that fire after this point don't try to >+ // access this WorkQueue <http://webkit.org/b/44690>. >+ ::DeleteTimerQueueEx(m_timerQueue, 0); >+} >+ >+void WorkQueue::dispatch(const Function<void()>& function) >+{ >+ MutexLocker locker(m_workItemQueueLock); >+ >+ m_workItemQueue.append(WorkItemWin::create(function, this)); >+ >+ // Spawn a work thread to perform the work we just added. As an optimization, we avoid >+ // spawning the thread if a work thread is already registered. This prevents multiple work >+ // threads from being spawned in most cases. (Note that when a work thread has been spawned but >+ // hasn't registered itself yet, m_isWorkThreadRegistered will be false and we'll end up >+ // spawning a second work thread here. But work thread registration process will ensure that >+ // only one thread actually ends up performing work.) >+ if (!m_isWorkThreadRegistered) >+ ::QueueUserWorkItem(workThreadCallback, this, WT_EXECUTEDEFAULT); >+} >+ >+struct TimerContext : public ThreadSafeRefCounted<TimerContext> { >+ static PassRefPtr<TimerContext> create() { return adoptRef(new TimerContext); } >+ >+ WorkQueue* queue; >+ Function<void()> function; >+ Mutex timerMutex; >+ HANDLE timer; >+ >+private: >+ TimerContext() : queue(0), timer(0) { } >+}; >+ >+void WorkQueue::timerCallback(void* context, BOOLEAN timerOrWaitFired) >+{ >+ ASSERT_ARG(context, context); >+ ASSERT_UNUSED(timerOrWaitFired, timerOrWaitFired); >+ >+ // Balanced by leakRef in scheduleWorkAfterDelay. >+ RefPtr<TimerContext> timerContext = adoptRef(static_cast<TimerContext*>(context)); >+ >+ timerContext->queue->dispatch(timerContext->function); >+ >+ MutexLocker lock(timerContext->timerMutex); >+ ASSERT(timerContext->timer); >+ ASSERT(timerContext->queue->m_timerQueue); >+ if (!::DeleteTimerQueueTimer(timerContext->queue->m_timerQueue, timerContext->timer, 0)) >+ ASSERT_WITH_MESSAGE(false, "::DeleteTimerQueueTimer failed with error %lu", ::GetLastError()); >+} >+ >+void WorkQueue::dispatchAfterDelay(const Function<void()>& function, double delay) >+{ >+ ASSERT(m_timerQueue); >+ >+ RefPtr<TimerContext> context = TimerContext::create(); >+ context->queue = this; >+ context->function = function; >+ >+ { >+ // The timer callback could fire before ::CreateTimerQueueTimer even returns, so we protect >+ // context->timer with a mutex to ensure the timer callback doesn't access it before the >+ // timer handle has been stored in it. >+ MutexLocker lock(context->timerMutex); >+ >+ // Since our timer callback is quick, we can execute in the timer thread itself and avoid >+ // an extra thread switch over to a worker thread. >+ if (!::CreateTimerQueueTimer(&context->timer, m_timerQueue, timerCallback, context.get(), delay * 1000, 0, WT_EXECUTEINTIMERTHREAD)) { >+ ASSERT_WITH_MESSAGE(false, "::CreateTimerQueueTimer failed with error %lu", ::GetLastError()); >+ return; >+ } >+ } >+ >+ // The timer callback will handle destroying context. >+ context.release().leakRef(); >+} >+ >+void WorkQueue::unregisterWaitAndDestroyItemSoon(PassRefPtr<HandleWorkItem> item) >+{ >+ // We're going to make a blocking call to ::UnregisterWaitEx before closing the handle. (The >+ // blocking version of ::UnregisterWaitEx is much simpler than the non-blocking version.) If we >+ // do this on the current thread, we'll deadlock if we're currently in a callback function for >+ // the wait we're unregistering. So instead we do it asynchronously on some other worker thread. >+ >+ ::QueueUserWorkItem(unregisterWaitAndDestroyItemCallback, item.leakRef(), WT_EXECUTEDEFAULT); >+} >+ >+DWORD WINAPI WorkQueue::unregisterWaitAndDestroyItemCallback(void* context) >+{ >+ ASSERT_ARG(context, context); >+ RefPtr<HandleWorkItem> item = adoptRef(static_cast<HandleWorkItem*>(context)); >+ >+ // Now that we know we're not in a callback function for the wait we're unregistering, we can >+ // make a blocking call to ::UnregisterWaitEx. >+ if (!::UnregisterWaitEx(item->waitHandle(), INVALID_HANDLE_VALUE)) { >+ DWORD error = ::GetLastError(); >+ ASSERT_NOT_REACHED(); >+ } >+ >+ return 0; >+} >+ >+} // namespace WTF >diff --git a/Source/WebKit2/CMakeLists.txt b/Source/WebKit2/CMakeLists.txt >index 03501bc5f8cede1316e1f30d94d49e50ebd7d718..632f27aed0cc5c6d067ed421b07630ad67548cf8 100644 >--- a/Source/WebKit2/CMakeLists.txt >+++ b/Source/WebKit2/CMakeLists.txt >@@ -102,7 +102,6 @@ SET(WebKit2_INCLUDE_DIRECTORIES > SET(WebKit2_SOURCES > Platform/Logging.cpp > Platform/Module.cpp >- Platform/WorkQueue.cpp > > Platform/CoreIPC/ArgumentCoders.cpp > Platform/CoreIPC/ArgumentDecoder.cpp >diff --git a/Source/WebKit2/GNUmakefile.list.am b/Source/WebKit2/GNUmakefile.list.am >index d420afa22f14a400791166813c51f321fae9f96e..fbdfe661583b47d263a479e93228fc3f7c8c78d4 100644 >--- a/Source/WebKit2/GNUmakefile.list.am >+++ b/Source/WebKit2/GNUmakefile.list.am >@@ -256,7 +256,6 @@ webkit2_sources += \ > Source/WebKit2/Platform/CoreIPC/unix/ConnectionUnix.cpp \ > Source/WebKit2/Platform/gtk/LoggingGtk.cpp \ > Source/WebKit2/Platform/gtk/ModuleGtk.cpp \ >- Source/WebKit2/Platform/gtk/WorkQueueGtk.cpp \ > Source/WebKit2/Platform/Logging.cpp \ > Source/WebKit2/Platform/Logging.h \ > Source/WebKit2/Platform/Module.cpp \ >@@ -264,8 +263,6 @@ webkit2_sources += \ > Source/WebKit2/Platform/PlatformProcessIdentifier.h \ > Source/WebKit2/Platform/SharedMemory.h \ > Source/WebKit2/Platform/unix/SharedMemoryUnix.cpp \ >- Source/WebKit2/Platform/WorkQueue.cpp \ >- Source/WebKit2/Platform/WorkQueue.h \ > Source/WebKit2/PluginProcess/PluginControllerProxy.cpp \ > Source/WebKit2/PluginProcess/PluginControllerProxy.h \ > Source/WebKit2/PluginProcess/PluginCreationParameters.cpp \ >@@ -1180,11 +1177,8 @@ webkit2_plugin_process_sources += \ > Source/WebKit2/Platform/CoreIPC/unix/ConnectionUnix.cpp \ > Source/WebKit2/Platform/Module.cpp \ > Source/WebKit2/Platform/Module.h \ >- Source/WebKit2/Platform/WorkQueue.cpp \ >- Source/WebKit2/Platform/WorkQueue.h \ > Source/WebKit2/Platform/SharedMemory.h \ > Source/WebKit2/Platform/gtk/ModuleGtk.cpp \ >- Source/WebKit2/Platform/gtk/WorkQueueGtk.cpp \ > Source/WebKit2/Platform/unix/SharedMemoryUnix.cpp \ > Source/WebKit2/PluginProcess/PluginControllerProxy.cpp \ > Source/WebKit2/PluginProcess/PluginControllerProxy.h \ >diff --git a/Source/WebKit2/Platform/CoreIPC/Connection.h b/Source/WebKit2/Platform/CoreIPC/Connection.h >index 773f6e0d13fb6ceac3cbaa50e30af117c2e020ed..a02f92e16010bc5b61dcc781fe63818f4ba96945 100644 >--- a/Source/WebKit2/Platform/CoreIPC/Connection.h >+++ b/Source/WebKit2/Platform/CoreIPC/Connection.h >@@ -32,11 +32,11 @@ > #include "ArgumentEncoder.h" > #include "Arguments.h" > #include "MessageID.h" >-#include "WorkQueue.h" > #include <wtf/HashMap.h> > #include <wtf/PassRefPtr.h> > #include <wtf/OwnPtr.h> > #include <wtf/Threading.h> >+#include <wtf/WorkQueue.h> > > #if OS(DARWIN) > #include <mach/mach_port.h> >@@ -47,7 +47,7 @@ class QSocketNotifier; > #endif > > #if PLATFORM(QT) || PLATFORM(GTK) || PLATFORM(EFL) >-#include "PlatformProcessIdentifier.h" >+#include <wtf/PlatformProcessIdentifier.h> > #endif > > namespace WebCore { >@@ -127,7 +127,7 @@ public: > #if OS(DARWIN) > void setShouldCloseConnectionOnMachExceptions(); > #elif PLATFORM(QT) >- void setShouldCloseConnectionOnProcessTermination(WebKit::PlatformProcessIdentifier); >+ void setShouldCloseConnectionOnProcessTermination(PlatformProcessIdentifier); > #endif > > void setOnlySendMessagesAsDispatchWhenWaitingForSyncReplyWhenProcessingSuchAMessage(bool); >diff --git a/Source/WebKit2/Platform/CoreIPC/unix/ConnectionUnix.cpp b/Source/WebKit2/Platform/CoreIPC/unix/ConnectionUnix.cpp >index 885e495cb7688c4e39172a72bae92de89405c987..49a508933dbc5fa9343c88fbde98c844030d5019 100644 >--- a/Source/WebKit2/Platform/CoreIPC/unix/ConnectionUnix.cpp >+++ b/Source/WebKit2/Platform/CoreIPC/unix/ConnectionUnix.cpp >@@ -557,7 +557,7 @@ bool Connection::sendOutgoingMessage(MessageID messageID, PassOwnPtr<ArgumentEnc > } > > #if PLATFORM(QT) >-void Connection::setShouldCloseConnectionOnProcessTermination(WebKit::PlatformProcessIdentifier process) >+void Connection::setShouldCloseConnectionOnProcessTermination(PlatformProcessIdentifier process) > { > m_connectionQueue.dispatchOnTermination(process, WTF::bind(&Connection::connectionDidClose, this)); > } >diff --git a/Source/WebKit2/Platform/PlatformProcessIdentifier.h b/Source/WebKit2/Platform/PlatformProcessIdentifier.h >deleted file mode 100644 >index 96ecbe87273afcdcfb079da40c2e6532c8cf8653..0000000000000000000000000000000000000000 >--- a/Source/WebKit2/Platform/PlatformProcessIdentifier.h >+++ /dev/null >@@ -1,57 +0,0 @@ >-/* >- * Copyright (C) 2010 Apple Inc. All rights reserved. >- * >- * Redistribution and use in source and binary forms, with or without >- * modification, are permitted provided that the following conditions >- * are met: >- * 1. Redistributions of source code must retain the above copyright >- * notice, this list of conditions and the following disclaimer. >- * 2. Redistributions in binary form must reproduce the above copyright >- * notice, this list of conditions and the following disclaimer in the >- * documentation and/or other materials provided with the distribution. >- * >- * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >- * THE POSSIBILITY OF SUCH DAMAGE. >- */ >- >- >-#ifndef PlatformProcessIdentifier_h >-#define PlatformProcessIdentifier_h >- >-#if PLATFORM(QT) >-class QProcess; >-#elif PLATFORM(EFL) >-#include <unistd.h> >-#endif >- >-namespace WebKit { >- >-#if PLATFORM(MAC) >-typedef pid_t PlatformProcessIdentifier; >-#elif PLATFORM(WIN) >-typedef HANDLE PlatformProcessIdentifier; >-#elif PLATFORM(QT) >-typedef QProcess* PlatformProcessIdentifier; >-#elif PLATFORM(GTK) >-#ifdef G_OS_WIN32 >-typedef void* GPid; >-#else >-typedef int GPid; >-#endif >-typedef GPid PlatformProcessIdentifier; >-#elif PLATFORM(EFL) >-typedef pid_t PlatformProcessIdentifier; >-#endif >- >-} // namespace WebKit >- >-#endif // PlatformProcessIdentifier_h >diff --git a/Source/WebKit2/Platform/WorkQueue.cpp b/Source/WebKit2/Platform/WorkQueue.cpp >deleted file mode 100644 >index 6bcdd226442308280560b89425ab16077fceb5da..0000000000000000000000000000000000000000 >--- a/Source/WebKit2/Platform/WorkQueue.cpp >+++ /dev/null >@@ -1,51 +0,0 @@ >-/* >- * Copyright (C) 2010 Apple Inc. All rights reserved. >- * >- * Redistribution and use in source and binary forms, with or without >- * modification, are permitted provided that the following conditions >- * are met: >- * 1. Redistributions of source code must retain the above copyright >- * notice, this list of conditions and the following disclaimer. >- * 2. Redistributions in binary form must reproduce the above copyright >- * notice, this list of conditions and the following disclaimer in the >- * documentation and/or other materials provided with the distribution. >- * >- * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >- * THE POSSIBILITY OF SUCH DAMAGE. >- */ >- >-#include "config.h" >-#include "WorkQueue.h" >- >-WorkQueue::WorkQueue(const char* name) >- : m_isValid(true) >-{ >- platformInitialize(name); >-} >- >-WorkQueue::~WorkQueue() >-{ >-#if !ASSERT_DISABLED >- MutexLocker locker(m_isValidMutex); >- ASSERT(!m_isValid); >-#endif >-} >- >-void WorkQueue::invalidate() >-{ >- { >- MutexLocker locker(m_isValidMutex); >- m_isValid = false; >- } >- >- platformInvalidate(); >-} >diff --git a/Source/WebKit2/Platform/WorkQueue.h b/Source/WebKit2/Platform/WorkQueue.h >deleted file mode 100644 >index d630dc02855e5da094b13f1f151329c2db41430c..0000000000000000000000000000000000000000 >--- a/Source/WebKit2/Platform/WorkQueue.h >+++ /dev/null >@@ -1,210 +0,0 @@ >-/* >- * Copyright (C) 2010 Apple Inc. All rights reserved. >- * Portions Copyright (c) 2010 Motorola Mobility, Inc. All rights reserved. >- * >- * Redistribution and use in source and binary forms, with or without >- * modification, are permitted provided that the following conditions >- * are met: >- * 1. Redistributions of source code must retain the above copyright >- * notice, this list of conditions and the following disclaimer. >- * 2. Redistributions in binary form must reproduce the above copyright >- * notice, this list of conditions and the following disclaimer in the >- * documentation and/or other materials provided with the distribution. >- * >- * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >- * THE POSSIBILITY OF SUCH DAMAGE. >- */ >- >-#ifndef WorkQueue_h >-#define WorkQueue_h >- >-#if OS(DARWIN) >-#if HAVE(DISPATCH_H) >-#include <dispatch/dispatch.h> >-#endif >-#endif >- >-#include <wtf/Forward.h> >-#include <wtf/Functional.h> >-#include <wtf/HashMap.h> >-#include <wtf/PassOwnPtr.h> >-#include <wtf/RefCounted.h> >-#include <wtf/Threading.h> >-#include <wtf/Vector.h> >- >-#if (PLATFORM(QT) && !OS(DARWIN)) || PLATFORM(GTK) || PLATFORM(EFL) >-#include "PlatformProcessIdentifier.h" >-#endif >- >-#if PLATFORM(QT) && !OS(DARWIN) >-#include <QSocketNotifier> >-class QObject; >-class QThread; >-#elif PLATFORM(GTK) >-#include <wtf/gobject/GRefPtr.h> >-typedef gboolean (*GSourceFunc) (gpointer data); >-#elif PLATFORM(EFL) >-#include <Ecore.h> >-#endif >- >-class WorkQueue { >- WTF_MAKE_NONCOPYABLE(WorkQueue); >- >-public: >- explicit WorkQueue(const char* name); >- ~WorkQueue(); >- >- // Will dispatch the given function to run as soon as possible. >- void dispatch(const Function<void()>&); >- >- // Will dispatch the given function after the given delay (in seconds). >- void dispatchAfterDelay(const Function<void()>&, double delay); >- >- void invalidate(); >- >-#if OS(DARWIN) >- enum MachPortEventType { >- // Fired when there is data on the given receive right. >- MachPortDataAvailable, >- >- // Fired when the receive right for this send right has been destroyed. >- MachPortDeadNameNotification >- }; >- >- // Will execute the given function whenever the given mach port event fires. >- // Note that this will adopt the mach port and destroy it when the work queue is invalidated. >- void registerMachPortEventHandler(mach_port_t, MachPortEventType, const Function<void()>&); >- void unregisterMachPortEventHandler(mach_port_t); >-#elif PLATFORM(WIN) >- void registerHandle(HANDLE, const Function<void()>&); >- void unregisterAndCloseHandle(HANDLE); >-#elif PLATFORM(QT) >- QSocketNotifier* registerSocketEventHandler(int, QSocketNotifier::Type, const Function<void()>&); >- void dispatchOnTermination(WebKit::PlatformProcessIdentifier, const Function<void()>&); >-#elif PLATFORM(GTK) >- void registerEventSourceHandler(int, int, const Function<void()>&); >- void unregisterEventSourceHandler(int); >- void dispatchOnTermination(WebKit::PlatformProcessIdentifier, const Function<void()>&); >-#elif PLATFORM(EFL) >- void registerSocketEventHandler(int, const Function<void()>&); >- void unregisterSocketEventHandler(int); >-#endif >- >-private: >- // FIXME: Use an atomic boolean here instead. >- Mutex m_isValidMutex; >- bool m_isValid; >- >- void platformInitialize(const char* name); >- void platformInvalidate(); >- >-#if OS(DARWIN) >-#if HAVE(DISPATCH_H) >- static void executeFunction(void*); >- Mutex m_eventSourcesMutex; >- class EventSource; >- HashMap<mach_port_t, EventSource*> m_eventSources; >- dispatch_queue_t m_dispatchQueue; >-#endif >-#elif PLATFORM(WIN) >- class WorkItemWin : public ThreadSafeRefCounted<WorkItemWin> { >- public: >- static PassRefPtr<WorkItemWin> create(const Function<void()>&, WorkQueue*); >- virtual ~WorkItemWin(); >- >- Function<void()>& function() { return m_function; } >- WorkQueue* queue() const { return m_queue; } >- >- protected: >- WorkItemWin(const Function<void()>&, WorkQueue*); >- >- private: >- Function<void()> m_function; >- WorkQueue* m_queue; >- }; >- >- class HandleWorkItem : public WorkItemWin { >- public: >- static PassRefPtr<HandleWorkItem> createByAdoptingHandle(HANDLE, const Function<void()>&, WorkQueue*); >- virtual ~HandleWorkItem(); >- >- void setWaitHandle(HANDLE waitHandle) { m_waitHandle = waitHandle; } >- HANDLE waitHandle() const { return m_waitHandle; } >- >- private: >- HandleWorkItem(HANDLE, const Function<void()>&, WorkQueue*); >- >- HANDLE m_handle; >- HANDLE m_waitHandle; >- }; >- >- static void CALLBACK handleCallback(void* context, BOOLEAN timerOrWaitFired); >- static void CALLBACK timerCallback(void* context, BOOLEAN timerOrWaitFired); >- static DWORD WINAPI workThreadCallback(void* context); >- >- bool tryRegisterAsWorkThread(); >- void unregisterAsWorkThread(); >- void performWorkOnRegisteredWorkThread(); >- >- static void unregisterWaitAndDestroyItemSoon(PassRefPtr<HandleWorkItem>); >- static DWORD WINAPI unregisterWaitAndDestroyItemCallback(void* context); >- >- volatile LONG m_isWorkThreadRegistered; >- >- Mutex m_workItemQueueLock; >- Vector<RefPtr<WorkItemWin> > m_workItemQueue; >- >- Mutex m_handlesLock; >- HashMap<HANDLE, RefPtr<HandleWorkItem> > m_handles; >- >- HANDLE m_timerQueue; >-#elif PLATFORM(QT) >- class WorkItemQt; >- QThread* m_workThread; >- friend class WorkItemQt; >-#elif PLATFORM(GTK) >- static void startWorkQueueThread(WorkQueue*); >- void workQueueThreadBody(); >- void dispatchOnSource(GSource*, const Function<void()>&, GSourceFunc); >- >- ThreadIdentifier m_workQueueThread; >- GRefPtr<GMainContext> m_eventContext; >- Mutex m_eventLoopLock; >- GRefPtr<GMainLoop> m_eventLoop; >- Mutex m_eventSourcesLock; >- class EventSource; >- HashMap<int, Vector<EventSource*> > m_eventSources; >- typedef HashMap<int, Vector<EventSource*> >::iterator EventSourceIterator; >-#elif PLATFORM(EFL) >- fd_set m_fileDescriptorSet; >- int m_maxFileDescriptor; >- int m_readFromPipeDescriptor; >- int m_writeToPipeDescriptor; >- bool m_threadLoop; >- >- Vector<Function<void()> > m_workItemQueue; >- Mutex m_workItemQueueLock; >- >- int m_socketDescriptor; >- Function<void()> m_socketEventHandler; >- >- HashMap<int, OwnPtr<Ecore_Timer> > m_timers; >- >- void sendMessageToThread(const char*); >- static void* workQueueThread(WorkQueue*); >- void performWork(); >- void performFileDescriptorWork(); >- static bool timerFired(void*); >-#endif >-}; >- >-#endif // WorkQueue_h >diff --git a/Source/WebKit2/Platform/efl/WorkQueueEfl.cpp b/Source/WebKit2/Platform/efl/WorkQueueEfl.cpp >deleted file mode 100644 >index 41ffedf5331a2a2eefd6b8c7f4f8fb0b7cf4461b..0000000000000000000000000000000000000000 >--- a/Source/WebKit2/Platform/efl/WorkQueueEfl.cpp >+++ /dev/null >@@ -1,173 +0,0 @@ >-/* >- Copyright (C) 2012 Samsung Electronics >- >- This library is free software; you can redistribute it and/or >- modify it under the terms of the GNU Library General Public >- License as published by the Free Software Foundation; either >- version 2 of the License, or (at your option) any later version. >- >- This library is distributed in the hope that it will be useful, >- but WITHOUT ANY WARRANTY; without even the implied warranty of >- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU >- Library General Public License for more details. >- >- You should have received a copy of the GNU Library General Public License >- along with this library; see the file COPYING.LIB. If not, write to >- the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, >- Boston, MA 02110-1301, USA. >- */ >- >-#include "config.h" >-#include "WorkQueue.h" >- >-#include <wtf/Assertions.h> >- >-class TimerWorkItem { >-public: >- TimerWorkItem(int timerID, const Function<void()>& function, WorkQueue* queue) >- : m_function(function) >- , m_queue(queue) >- , m_timerID(timerID) >- { >- } >- ~TimerWorkItem() { } >- >- Function<void()> function() const { return m_function; } >- WorkQueue* queue() const { return m_queue; } >- >- int timerID() const { return m_timerID; } >- >-private: >- Function<void()> m_function; >- WorkQueue* m_queue; >- int m_timerID; >-}; >- >-static const int invalidSocketDescriptor = -1; >-static const int threadMessageSize = 1; >-static const char finishThreadMessage[] = "F"; >-static const char wakupThreadMessage[] = "W"; >- >-void WorkQueue::platformInitialize(const char* name) >-{ >- int fds[2]; >- if (pipe(fds)) >- ASSERT_NOT_REACHED(); >- >- m_readFromPipeDescriptor = fds[0]; >- m_writeToPipeDescriptor = fds[1]; >- FD_ZERO(&m_fileDescriptorSet); >- FD_SET(m_readFromPipeDescriptor, &m_fileDescriptorSet); >- m_maxFileDescriptor = m_readFromPipeDescriptor; >- >- m_socketDescriptor = invalidSocketDescriptor; >- >- m_threadLoop = true; >- createThread(reinterpret_cast<WTF::ThreadFunction>(&WorkQueue::workQueueThread), this, name); >-} >- >-void WorkQueue::platformInvalidate() >-{ >- sendMessageToThread(finishThreadMessage); >-} >- >-void WorkQueue::performWork() >-{ >- m_workItemQueueLock.lock(); >- >- while (!m_workItemQueue.isEmpty()) { >- Vector<Function<void()> > workItemQueue; >- m_workItemQueue.swap(workItemQueue); >- >- m_workItemQueueLock.unlock(); >- for (size_t i = 0; i < workItemQueue.size(); ++i) >- workItemQueue[i](); >- m_workItemQueueLock.lock(); >- } >- m_workItemQueueLock.unlock(); >-} >- >-void WorkQueue::performFileDescriptorWork() >-{ >- fd_set readFileDescriptorSet = m_fileDescriptorSet; >- >- if (select(m_maxFileDescriptor + 1, &readFileDescriptorSet, 0, 0, 0) >= 0) { >- if (FD_ISSET(m_readFromPipeDescriptor, &readFileDescriptorSet)) { >- char readBuf[threadMessageSize]; >- if (read(m_readFromPipeDescriptor, readBuf, threadMessageSize) == -1) >- LOG_ERROR("Failed to read from WorkQueueThread pipe"); >- if (!strncmp(readBuf, finishThreadMessage, threadMessageSize)) >- m_threadLoop = false; >- } >- >- if (m_socketDescriptor != invalidSocketDescriptor && FD_ISSET(m_socketDescriptor, &readFileDescriptorSet)) >- m_socketEventHandler(); >- } >-} >- >-void WorkQueue::sendMessageToThread(const char* message) >-{ >- if (write(m_writeToPipeDescriptor, message, threadMessageSize) == -1) >- LOG_ERROR("Failed to wake up WorkQueue Thread"); >-} >- >-void* WorkQueue::workQueueThread(WorkQueue* workQueue) >-{ >- while (workQueue->m_threadLoop) { >- workQueue->performWork(); >- workQueue->performFileDescriptorWork(); >- } >- >- close(workQueue->m_readFromPipeDescriptor); >- close(workQueue->m_writeToPipeDescriptor); >- >- return 0; >-} >- >-void WorkQueue::registerSocketEventHandler(int fileDescriptor, const Function<void()>& function) >-{ >- if (m_socketDescriptor != invalidSocketDescriptor) >- LOG_ERROR("%d is already registerd.", fileDescriptor); >- >- m_socketDescriptor = fileDescriptor; >- m_socketEventHandler = function; >- >- if (fileDescriptor > m_maxFileDescriptor) >- m_maxFileDescriptor = fileDescriptor; >- FD_SET(fileDescriptor, &m_fileDescriptorSet); >-} >- >-void WorkQueue::unregisterSocketEventHandler(int fileDescriptor) >-{ >- m_socketDescriptor = invalidSocketDescriptor; >- >- if (fileDescriptor == m_maxFileDescriptor) >- m_maxFileDescriptor = m_readFromPipeDescriptor; >- FD_CLR(fileDescriptor, &m_fileDescriptorSet); >-} >- >-void WorkQueue::dispatch(const Function<void()>& function) >-{ >- MutexLocker locker(m_workItemQueueLock); >- m_workItemQueue.append(function); >- sendMessageToThread(wakupThreadMessage); >-} >- >-bool WorkQueue::timerFired(void* data) >-{ >- TimerWorkItem* item = static_cast<TimerWorkItem*>(data); >- if (item && item->queue()->m_isValid) { >- item->queue()->dispatch(item->function()); >- item->queue()->m_timers.take(item->timerID()); >- delete item; >- } >- >- return ECORE_CALLBACK_CANCEL; >-} >- >-void WorkQueue::dispatchAfterDelay(const Function<void()>& function, double delay) >-{ >- static int timerId = 1; >- m_timers.set(timerId, adoptPtr(ecore_timer_add(delay, reinterpret_cast<Ecore_Task_Cb>(timerFired), new TimerWorkItem(timerId, function, this)))); >- timerId++; >-} >diff --git a/Source/WebKit2/Platform/gtk/WorkQueueGtk.cpp b/Source/WebKit2/Platform/gtk/WorkQueueGtk.cpp >deleted file mode 100644 >index 1dfab83ccfb24c9f00ee40d2daa1c95b16382a43..0000000000000000000000000000000000000000 >--- a/Source/WebKit2/Platform/gtk/WorkQueueGtk.cpp >+++ /dev/null >@@ -1,230 +0,0 @@ >-/* >- * Copyright (C) 2011 Igalia S.L. >- * Copyright (C) 2010 Apple Inc. All rights reserved. >- * Portions Copyright (c) 2010 Motorola Mobility, Inc. All rights reserved. >- * >- * Redistribution and use in source and binary forms, with or without >- * modification, are permitted provided that the following conditions >- * are met: >- * 1. Redistributions of source code must retain the above copyright >- * notice, this list of conditions and the following disclaimer. >- * 2. Redistributions in binary form must reproduce the above copyright >- * notice, this list of conditions and the following disclaimer in the >- * documentation and/or other materials provided with the distribution. >- * >- * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >- * THE POSSIBILITY OF SUCH DAMAGE. >- */ >- >-#include "config.h" >-#include "WorkQueue.h" >- >-#include "WKBase.h" >-#include <gio/gio.h> >-#include <glib.h> >-#include <wtf/gobject/GRefPtr.h> >- >-// WorkQueue::EventSource >-class WorkQueue::EventSource { >-public: >- EventSource(const Function<void()>& function, WorkQueue* workQueue, GCancellable* cancellable) >- : m_function(function) >- , m_workQueue(workQueue) >- , m_cancellable(cancellable) >- { >- } >- >- void cancel() >- { >- if (!m_cancellable) >- return; >- g_cancellable_cancel(m_cancellable); >- } >- >- static void executeEventSource(EventSource* eventSource) >- { >- ASSERT(eventSource); >- WorkQueue* queue = eventSource->m_workQueue; >- { >- MutexLocker locker(queue->m_isValidMutex); >- if (!queue->m_isValid) >- return; >- } >- >- eventSource->m_function(); >- } >- >- static gboolean performWorkOnce(EventSource* eventSource) >- { >- executeEventSource(eventSource); >- return FALSE; >- } >- >- static gboolean performWork(GSocket* socket, GIOCondition condition, EventSource* eventSource) >- { >- if (!(condition & G_IO_IN) && !(condition & G_IO_HUP) && !(condition & G_IO_ERR)) { >- // EventSource has been cancelled, return FALSE to destroy the source. >- return FALSE; >- } >- >- executeEventSource(eventSource); >- return TRUE; >- } >- >- static gboolean performWorkOnTermination(GPid, gint, EventSource* eventSource) >- { >- executeEventSource(eventSource); >- return FALSE; >- } >- >- static void deleteEventSource(EventSource* eventSource) >- { >- ASSERT(eventSource); >- delete eventSource; >- } >- >-public: >- Function<void()> m_function; >- WorkQueue* m_workQueue; >- GCancellable* m_cancellable; >-}; >- >-// WorkQueue >-static const size_t kVisualStudioThreadNameLimit = 31; >- >-void WorkQueue::platformInitialize(const char* name) >-{ >- m_eventContext = adoptGRef(g_main_context_new()); >- ASSERT(m_eventContext); >- m_eventLoop = adoptGRef(g_main_loop_new(m_eventContext.get(), FALSE)); >- ASSERT(m_eventLoop); >- >- // This name can be com.apple.WebKit.ProcessLauncher or com.apple.CoreIPC.ReceiveQueue. >- // We are using those names for the thread name, but both are longer than 31 characters, >- // which is the limit of Visual Studio for thread names. >- // When log is enabled createThread() will assert instead of truncate the name, so we need >- // to make sure we don't use a name longer than 31 characters. >- const char* threadName = g_strrstr(name, "."); >- if (threadName) >- threadName++; >- else >- threadName = name; >- if (strlen(threadName) > kVisualStudioThreadNameLimit) >- threadName += strlen(threadName) - kVisualStudioThreadNameLimit; >- >- m_workQueueThread = createThread(reinterpret_cast<WTF::ThreadFunction>(&WorkQueue::startWorkQueueThread), this, threadName); >-} >- >-void WorkQueue::platformInvalidate() >-{ >- MutexLocker locker(m_eventLoopLock); >- >- if (m_eventLoop) { >- if (g_main_loop_is_running(m_eventLoop.get())) >- g_main_loop_quit(m_eventLoop.get()); >- m_eventLoop.clear(); >- } >- >- m_eventContext.clear(); >-} >- >-void WorkQueue::startWorkQueueThread(WorkQueue* workQueue) >-{ >- workQueue->workQueueThreadBody(); >-} >- >-void WorkQueue::workQueueThreadBody() >-{ >- g_main_loop_run(m_eventLoop.get()); >-} >- >-void WorkQueue::registerEventSourceHandler(int fileDescriptor, int condition, const Function<void()>& function) >-{ >- GRefPtr<GSocket> socket = adoptGRef(g_socket_new_from_fd(fileDescriptor, 0)); >- ASSERT(socket); >- GRefPtr<GCancellable> cancellable = adoptGRef(g_cancellable_new()); >- GRefPtr<GSource> dispatchSource = adoptGRef(g_socket_create_source(socket.get(), static_cast<GIOCondition>(condition), cancellable.get())); >- ASSERT(dispatchSource); >- EventSource* eventSource = new EventSource(function, this, cancellable.get()); >- ASSERT(eventSource); >- >- g_source_set_callback(dispatchSource.get(), reinterpret_cast<GSourceFunc>(&WorkQueue::EventSource::performWork), >- eventSource, reinterpret_cast<GDestroyNotify>(&WorkQueue::EventSource::deleteEventSource)); >- >- // Set up the event sources under the mutex since this is shared across multiple threads. >- { >- MutexLocker locker(m_eventSourcesLock); >- Vector<EventSource*> sources; >- EventSourceIterator it = m_eventSources.find(fileDescriptor); >- if (it != m_eventSources.end()) >- sources = it->second; >- >- sources.append(eventSource); >- m_eventSources.set(fileDescriptor, sources); >- } >- >- g_source_attach(dispatchSource.get(), m_eventContext.get()); >-} >- >-void WorkQueue::unregisterEventSourceHandler(int fileDescriptor) >-{ >- ASSERT(fileDescriptor); >- >- MutexLocker locker(m_eventSourcesLock); >- >- EventSourceIterator it = m_eventSources.find(fileDescriptor); >- ASSERT(it != m_eventSources.end()); >- ASSERT(m_eventSources.contains(fileDescriptor)); >- >- if (it != m_eventSources.end()) { >- Vector<EventSource*> sources = it->second; >- for (unsigned i = 0; i < sources.size(); i++) >- sources[i]->cancel(); >- >- m_eventSources.remove(it); >- } >-} >- >-void WorkQueue::dispatchOnSource(GSource* dispatchSource, const Function<void()>& function, GSourceFunc sourceCallback) >-{ >- EventSource* eventSource = new EventSource(function, this, 0); >- >- g_source_set_callback(dispatchSource, sourceCallback, eventSource, >- reinterpret_cast<GDestroyNotify>(&WorkQueue::EventSource::deleteEventSource)); >- >- g_source_attach(dispatchSource, m_eventContext.get()); >-} >- >-void WorkQueue::dispatch(const Function<void()>& function) >-{ >- GRefPtr<GSource> dispatchSource = adoptGRef(g_idle_source_new()); >- ASSERT(dispatchSource); >- g_source_set_priority(dispatchSource.get(), G_PRIORITY_DEFAULT); >- >- dispatchOnSource(dispatchSource.get(), function, reinterpret_cast<GSourceFunc>(&WorkQueue::EventSource::performWorkOnce)); >-} >- >-void WorkQueue::dispatchAfterDelay(const Function<void()>& function, double delay) >-{ >- GRefPtr<GSource> dispatchSource = adoptGRef(g_timeout_source_new(static_cast<guint>(delay * 1000))); >- ASSERT(dispatchSource); >- >- dispatchOnSource(dispatchSource.get(), function, reinterpret_cast<GSourceFunc>(&WorkQueue::EventSource::performWorkOnce)); >-} >- >-void WorkQueue::dispatchOnTermination(WebKit::PlatformProcessIdentifier process, const Function<void()>& function) >-{ >- GRefPtr<GSource> dispatchSource = adoptGRef(g_child_watch_source_new(process)); >- ASSERT(dispatchSource); >- >- dispatchOnSource(dispatchSource.get(), function, reinterpret_cast<GSourceFunc>(&WorkQueue::EventSource::performWorkOnTermination)); >-} >diff --git a/Source/WebKit2/Platform/mac/WorkQueueMac.cpp b/Source/WebKit2/Platform/mac/WorkQueueMac.cpp >deleted file mode 100644 >index ae473ee5cc84e58429b0439ccd921ac2c492ffaa..0000000000000000000000000000000000000000 >--- a/Source/WebKit2/Platform/mac/WorkQueueMac.cpp >+++ /dev/null >@@ -1,178 +0,0 @@ >-/* >- * Copyright (C) 2010 Apple Inc. All rights reserved. >- * >- * Redistribution and use in source and binary forms, with or without >- * modification, are permitted provided that the following conditions >- * are met: >- * 1. Redistributions of source code must retain the above copyright >- * notice, this list of conditions and the following disclaimer. >- * 2. Redistributions in binary form must reproduce the above copyright >- * notice, this list of conditions and the following disclaimer in the >- * documentation and/or other materials provided with the distribution. >- * >- * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >- * THE POSSIBILITY OF SUCH DAMAGE. >- */ >- >-#include "config.h" >-#include "WorkQueue.h" >- >-#include <mach/mach_init.h> >-#include <mach/mach_port.h> >-#include <wtf/PassOwnPtr.h> >- >-void WorkQueue::executeFunction(void* context) >-{ >- WorkQueue* queue = static_cast<WorkQueue*>(dispatch_get_context(dispatch_get_current_queue())); >- OwnPtr<Function<void()> > function = adoptPtr(static_cast<Function<void()>*>(context)); >- >- { >- MutexLocker locker(queue->m_isValidMutex); >- if (!queue->m_isValid) >- return; >- } >- >- (*function)(); >-} >- >-void WorkQueue::dispatch(const Function<void()>& function) >-{ >- dispatch_async_f(m_dispatchQueue, new Function<void()>(function), executeFunction); >-} >- >-void WorkQueue::dispatchAfterDelay(const Function<void()>& function, double delay) >-{ >- dispatch_time_t delayTime = dispatch_time(DISPATCH_TIME_NOW, delay * NSEC_PER_SEC); >- >- dispatch_after_f(delayTime, m_dispatchQueue, new Function<void()>(function), executeFunction); >-} >- >-class WorkQueue::EventSource { >-public: >- EventSource(MachPortEventType eventType, dispatch_source_t dispatchSource, const Function<void()>& function) >- : m_eventType(eventType) >- , m_dispatchSource(dispatchSource) >- , m_function(function) >- { >- } >- >- dispatch_source_t dispatchSource() const { return m_dispatchSource; } >- >- static void eventHandler(void* source) >- { >- EventSource* eventSource = static_cast<EventSource*>(source); >- >- eventSource->m_function(); >- } >- >- static void cancelHandler(void* source) >- { >- EventSource* eventSource = static_cast<EventSource*>(source); >- >- mach_port_t machPort = dispatch_source_get_handle(eventSource->m_dispatchSource); >- >- switch (eventSource->m_eventType) { >- case MachPortDataAvailable: >- // Release our receive right. >- mach_port_mod_refs(mach_task_self(), machPort, MACH_PORT_RIGHT_RECEIVE, -1); >- break; >- case MachPortDeadNameNotification: >- // Release our send right. >- mach_port_deallocate(mach_task_self(), machPort); >- break; >- } >- } >- >- static void finalizeHandler(void* source) >- { >- EventSource* eventSource = static_cast<EventSource*>(source); >- >- delete eventSource; >- } >- >-private: >- MachPortEventType m_eventType; >- >- // This is a weak reference, since m_dispatchSource references the event source. >- dispatch_source_t m_dispatchSource; >- >- Function<void()> m_function; >-}; >- >-void WorkQueue::registerMachPortEventHandler(mach_port_t machPort, MachPortEventType eventType, const Function<void()>& function) >-{ >- dispatch_source_type_t sourceType = 0; >- switch (eventType) { >- case MachPortDataAvailable: >- sourceType = DISPATCH_SOURCE_TYPE_MACH_RECV; >- break; >- case MachPortDeadNameNotification: >- sourceType = DISPATCH_SOURCE_TYPE_MACH_SEND; >- break; >- } >- >- dispatch_source_t dispatchSource = dispatch_source_create(sourceType, machPort, 0, m_dispatchQueue); >- >- EventSource* eventSource = new EventSource(eventType, dispatchSource, function); >- dispatch_set_context(dispatchSource, eventSource); >- >- dispatch_source_set_event_handler_f(dispatchSource, &EventSource::eventHandler); >- dispatch_source_set_cancel_handler_f(dispatchSource, &EventSource::cancelHandler); >- dispatch_set_finalizer_f(dispatchSource, &EventSource::finalizeHandler); >- >- // Add the source to our set of sources. >- { >- MutexLocker locker(m_eventSourcesMutex); >- >- ASSERT(!m_eventSources.contains(machPort)); >- >- m_eventSources.set(machPort, eventSource); >- >- // And start it! >- dispatch_resume(dispatchSource); >- } >-} >- >-void WorkQueue::unregisterMachPortEventHandler(mach_port_t machPort) >-{ >- ASSERT(machPort); >- >- MutexLocker locker(m_eventSourcesMutex); >- >- HashMap<mach_port_t, EventSource*>::iterator it = m_eventSources.find(machPort); >- ASSERT(it != m_eventSources.end()); >- >- ASSERT(m_eventSources.contains(machPort)); >- >- EventSource* eventSource = it->second; >- // Cancel and release the source. It will be deleted in its finalize handler. >- dispatch_source_cancel(eventSource->dispatchSource()); >- dispatch_release(eventSource->dispatchSource()); >- >- m_eventSources.remove(it); >-} >- >-void WorkQueue::platformInitialize(const char* name) >-{ >- m_dispatchQueue = dispatch_queue_create(name, 0); >- dispatch_set_context(m_dispatchQueue, this); >-} >- >-void WorkQueue::platformInvalidate() >-{ >-#if !ASSERT_DISABLED >- MutexLocker locker(m_eventSourcesMutex); >- ASSERT(m_eventSources.isEmpty()); >-#endif >- >- dispatch_release(m_dispatchQueue); >-} >diff --git a/Source/WebKit2/Platform/qt/WorkQueueQt.cpp b/Source/WebKit2/Platform/qt/WorkQueueQt.cpp >deleted file mode 100644 >index aaa2be3d0b8b748529a288fee2d594fdb9e49926..0000000000000000000000000000000000000000 >--- a/Source/WebKit2/Platform/qt/WorkQueueQt.cpp >+++ /dev/null >@@ -1,130 +0,0 @@ >-/* >- * Copyright (C) 2010 Apple Inc. All rights reserved. >- * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies) >- * >- * Redistribution and use in source and binary forms, with or without >- * modification, are permitted provided that the following conditions >- * are met: >- * 1. Redistributions of source code must retain the above copyright >- * notice, this list of conditions and the following disclaimer. >- * 2. Redistributions in binary form must reproduce the above copyright >- * notice, this list of conditions and the following disclaimer in the >- * documentation and/or other materials provided with the distribution. >- * >- * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >- * THE POSSIBILITY OF SUCH DAMAGE. >- */ >- >-#include "config.h" >-#include "WorkQueue.h" >- >-#include <QLocalSocket> >-#include <QObject> >-#include <QThread> >-#include <QProcess> >-#include <WebCore/NotImplemented.h> >-#include <wtf/Threading.h> >- >-class WorkQueue::WorkItemQt : public QObject { >- Q_OBJECT >-public: >- WorkItemQt(WorkQueue* workQueue, const Function<void()>& function) >- : m_queue(workQueue) >- , m_source(0) >- , m_signal(0) >- , m_function(function) >- { >- } >- >- WorkItemQt(WorkQueue* workQueue, QObject* source, const char* signal, const Function<void()>& function) >- : m_queue(workQueue) >- , m_source(source) >- , m_signal(signal) >- , m_function(function) >- { >- connect(m_source, m_signal, SLOT(execute()), Qt::QueuedConnection); >- } >- >- ~WorkItemQt() >- { >- } >- >- Q_SLOT void execute() >- { >- if (m_queue->m_isValid) >- m_function(); >- } >- >- Q_SLOT void executeAndDelete() >- { >- execute(); >- delete this; >- } >- >- virtual void timerEvent(QTimerEvent*) >- { >- executeAndDelete(); >- } >- >- WorkQueue* m_queue; >- QObject* m_source; >- const char* m_signal; >- Function<void()> m_function; >-}; >- >-QSocketNotifier* WorkQueue::registerSocketEventHandler(int socketDescriptor, QSocketNotifier::Type type, const Function<void()>& function) >-{ >- ASSERT(m_workThread); >- >- QSocketNotifier* notifier = new QSocketNotifier(socketDescriptor, type, 0); >- notifier->setEnabled(false); >- notifier->moveToThread(m_workThread); >- WorkQueue::WorkItemQt* itemQt = new WorkQueue::WorkItemQt(this, notifier, SIGNAL(activated(int)), function); >- itemQt->moveToThread(m_workThread); >- notifier->setEnabled(true); >- return notifier; >-} >- >-void WorkQueue::platformInitialize(const char*) >-{ >- m_workThread = new QThread(); >- m_workThread->start(); >-} >- >-void WorkQueue::platformInvalidate() >-{ >- m_workThread->exit(); >- m_workThread->wait(); >- delete m_workThread; >-} >- >-void WorkQueue::dispatch(const Function<void()>& function) >-{ >- WorkQueue::WorkItemQt* itemQt = new WorkQueue::WorkItemQt(this, function); >- itemQt->moveToThread(m_workThread); >- QMetaObject::invokeMethod(itemQt, "executeAndDelete", Qt::QueuedConnection); >-} >- >-void WorkQueue::dispatchAfterDelay(const Function<void()>& function, double delayInSecond) >-{ >- WorkQueue::WorkItemQt* itemQt = new WorkQueue::WorkItemQt(this, function); >- itemQt->startTimer(static_cast<int>(delayInSecond * 1000)); >- itemQt->moveToThread(m_workThread); >-} >- >-void WorkQueue::dispatchOnTermination(WebKit::PlatformProcessIdentifier process, const Function<void()>& function) >-{ >- WorkQueue::WorkItemQt* itemQt = new WorkQueue::WorkItemQt(this, process, SIGNAL(finished(int, QProcess::ExitStatus)), function); >- itemQt->moveToThread(m_workThread); >-} >- >-#include "WorkQueueQt.moc" >diff --git a/Source/WebKit2/Platform/win/WorkQueueWin.cpp b/Source/WebKit2/Platform/win/WorkQueueWin.cpp >deleted file mode 100644 >index aabadbda895e07d9ee5330795cc94e617eb91d7b..0000000000000000000000000000000000000000 >--- a/Source/WebKit2/Platform/win/WorkQueueWin.cpp >+++ /dev/null >@@ -1,291 +0,0 @@ >-/* >- * Copyright (C) 2010 Apple Inc. All rights reserved. >- * >- * Redistribution and use in source and binary forms, with or without >- * modification, are permitted provided that the following conditions >- * are met: >- * 1. Redistributions of source code must retain the above copyright >- * notice, this list of conditions and the following disclaimer. >- * 2. Redistributions in binary form must reproduce the above copyright >- * notice, this list of conditions and the following disclaimer in the >- * documentation and/or other materials provided with the distribution. >- * >- * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' >- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, >- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS >- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR >- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF >- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS >- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN >- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) >- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF >- * THE POSSIBILITY OF SUCH DAMAGE. >- */ >- >-#include "config.h" >-#include "WorkQueue.h" >- >-#include <WebCore/NotImplemented.h> >-#include <wtf/Threading.h> >- >-inline WorkQueue::WorkItemWin::WorkItemWin(const Function<void()>& function, WorkQueue* queue) >- : m_function(function) >- , m_queue(queue) >-{ >-} >- >-PassRefPtr<WorkQueue::WorkItemWin> WorkQueue::WorkItemWin::create(const Function<void()>& function, WorkQueue* queue) >-{ >- return adoptRef(new WorkItemWin(function, queue)); >-} >- >-WorkQueue::WorkItemWin::~WorkItemWin() >-{ >-} >- >-inline WorkQueue::HandleWorkItem::HandleWorkItem(HANDLE handle, const Function<void()>& function, WorkQueue* queue) >- : WorkItemWin(function, queue) >- , m_handle(handle) >- , m_waitHandle(0) >-{ >- ASSERT_ARG(handle, handle); >-} >- >-PassRefPtr<WorkQueue::HandleWorkItem> WorkQueue::HandleWorkItem::createByAdoptingHandle(HANDLE handle, const Function<void()>& function, WorkQueue* queue) >-{ >- return adoptRef(new HandleWorkItem(handle, function, queue)); >-} >- >-WorkQueue::HandleWorkItem::~HandleWorkItem() >-{ >- ::CloseHandle(m_handle); >-} >- >-void WorkQueue::handleCallback(void* context, BOOLEAN timerOrWaitFired) >-{ >- ASSERT_ARG(context, context); >- ASSERT_ARG(timerOrWaitFired, !timerOrWaitFired); >- >- WorkItemWin* item = static_cast<WorkItemWin*>(context); >- WorkQueue* queue = item->queue(); >- >- { >- MutexLocker lock(queue->m_workItemQueueLock); >- queue->m_workItemQueue.append(item); >- >- // If no other thread is performing work, we can do it on this thread. >- if (!queue->tryRegisterAsWorkThread()) { >- // Some other thread is performing work. Since we hold the queue lock, we can be sure >- // that the work thread is not exiting due to an empty queue and will process the work >- // item we just added to it. If we weren't holding the lock we'd have to signal >- // m_performWorkEvent to make sure the work item got picked up. >- return; >- } >- } >- >- queue->performWorkOnRegisteredWorkThread(); >-} >- >-void WorkQueue::registerHandle(HANDLE handle, const Function<void()>& function) >-{ >- RefPtr<HandleWorkItem> handleItem = HandleWorkItem::createByAdoptingHandle(handle, function, this); >- >- { >- MutexLocker lock(m_handlesLock); >- ASSERT_ARG(handle, !m_handles.contains(handle)); >- m_handles.set(handle, handleItem); >- } >- >- HANDLE waitHandle; >- if (!::RegisterWaitForSingleObject(&waitHandle, handle, handleCallback, handleItem.get(), INFINITE, WT_EXECUTEDEFAULT)) { >- DWORD error = ::GetLastError(); >- ASSERT_NOT_REACHED(); >- } >- handleItem->setWaitHandle(waitHandle); >-} >- >-void WorkQueue::unregisterAndCloseHandle(HANDLE handle) >-{ >- RefPtr<HandleWorkItem> item; >- { >- MutexLocker locker(m_handlesLock); >- ASSERT_ARG(handle, m_handles.contains(handle)); >- item = m_handles.take(handle); >- } >- >- unregisterWaitAndDestroyItemSoon(item.release()); >-} >- >-DWORD WorkQueue::workThreadCallback(void* context) >-{ >- ASSERT_ARG(context, context); >- >- WorkQueue* queue = static_cast<WorkQueue*>(context); >- >- if (!queue->tryRegisterAsWorkThread()) >- return 0; >- >- queue->performWorkOnRegisteredWorkThread(); >- return 0; >-} >- >-void WorkQueue::performWorkOnRegisteredWorkThread() >-{ >- ASSERT(m_isWorkThreadRegistered); >- >- bool isValid = true; >- >- m_workItemQueueLock.lock(); >- >- while (isValid && !m_workItemQueue.isEmpty()) { >- Vector<RefPtr<WorkItemWin> > workItemQueue; >- m_workItemQueue.swap(workItemQueue); >- >- // Allow more work to be scheduled while we're not using the queue directly. >- m_workItemQueueLock.unlock(); >- for (size_t i = 0; i < workItemQueue.size(); ++i) { >- MutexLocker locker(m_isValidMutex); >- isValid = m_isValid; >- if (!isValid) >- break; >- workItemQueue[i]->function()(); >- } >- m_workItemQueueLock.lock(); >- } >- >- // One invariant we maintain is that any work scheduled while a work thread is registered will >- // be handled by that work thread. Unregister as the work thread while the queue lock is still >- // held so that no work can be scheduled while we're still registered. >- unregisterAsWorkThread(); >- >- m_workItemQueueLock.unlock(); >-} >- >-void WorkQueue::platformInitialize(const char* name) >-{ >- m_isWorkThreadRegistered = 0; >- m_timerQueue = ::CreateTimerQueue(); >- ASSERT_WITH_MESSAGE(m_timerQueue, "::CreateTimerQueue failed with error %lu", ::GetLastError()); >-} >- >-bool WorkQueue::tryRegisterAsWorkThread() >-{ >- LONG result = ::InterlockedCompareExchange(&m_isWorkThreadRegistered, 1, 0); >- ASSERT(!result || result == 1); >- return !result; >-} >- >-void WorkQueue::unregisterAsWorkThread() >-{ >- LONG result = ::InterlockedCompareExchange(&m_isWorkThreadRegistered, 0, 1); >- ASSERT_UNUSED(result, result == 1); >-} >- >-void WorkQueue::platformInvalidate() >-{ >-#if !ASSERT_DISABLED >- MutexLocker lock(m_handlesLock); >- ASSERT(m_handles.isEmpty()); >-#endif >- >- // FIXME: We need to ensure that any timer-queue timers that fire after this point don't try to >- // access this WorkQueue <http://webkit.org/b/44690>. >- ::DeleteTimerQueueEx(m_timerQueue, 0); >-} >- >-void WorkQueue::dispatch(const Function<void()>& function) >-{ >- MutexLocker locker(m_workItemQueueLock); >- >- m_workItemQueue.append(WorkItemWin::create(function, this)); >- >- // Spawn a work thread to perform the work we just added. As an optimization, we avoid >- // spawning the thread if a work thread is already registered. This prevents multiple work >- // threads from being spawned in most cases. (Note that when a work thread has been spawned but >- // hasn't registered itself yet, m_isWorkThreadRegistered will be false and we'll end up >- // spawning a second work thread here. But work thread registration process will ensure that >- // only one thread actually ends up performing work.) >- if (!m_isWorkThreadRegistered) >- ::QueueUserWorkItem(workThreadCallback, this, WT_EXECUTEDEFAULT); >-} >- >-struct TimerContext : public ThreadSafeRefCounted<TimerContext> { >- static PassRefPtr<TimerContext> create() { return adoptRef(new TimerContext); } >- >- WorkQueue* queue; >- Function<void()> function; >- Mutex timerMutex; >- HANDLE timer; >- >-private: >- TimerContext() : queue(0), timer(0) { } >-}; >- >-void WorkQueue::timerCallback(void* context, BOOLEAN timerOrWaitFired) >-{ >- ASSERT_ARG(context, context); >- ASSERT_UNUSED(timerOrWaitFired, timerOrWaitFired); >- >- // Balanced by leakRef in scheduleWorkAfterDelay. >- RefPtr<TimerContext> timerContext = adoptRef(static_cast<TimerContext*>(context)); >- >- timerContext->queue->dispatch(timerContext->function); >- >- MutexLocker lock(timerContext->timerMutex); >- ASSERT(timerContext->timer); >- ASSERT(timerContext->queue->m_timerQueue); >- if (!::DeleteTimerQueueTimer(timerContext->queue->m_timerQueue, timerContext->timer, 0)) >- ASSERT_WITH_MESSAGE(false, "::DeleteTimerQueueTimer failed with error %lu", ::GetLastError()); >-} >- >-void WorkQueue::dispatchAfterDelay(const Function<void()>& function, double delay) >-{ >- ASSERT(m_timerQueue); >- >- RefPtr<TimerContext> context = TimerContext::create(); >- context->queue = this; >- context->function = function; >- >- { >- // The timer callback could fire before ::CreateTimerQueueTimer even returns, so we protect >- // context->timer with a mutex to ensure the timer callback doesn't access it before the >- // timer handle has been stored in it. >- MutexLocker lock(context->timerMutex); >- >- // Since our timer callback is quick, we can execute in the timer thread itself and avoid >- // an extra thread switch over to a worker thread. >- if (!::CreateTimerQueueTimer(&context->timer, m_timerQueue, timerCallback, context.get(), delay * 1000, 0, WT_EXECUTEINTIMERTHREAD)) { >- ASSERT_WITH_MESSAGE(false, "::CreateTimerQueueTimer failed with error %lu", ::GetLastError()); >- return; >- } >- } >- >- // The timer callback will handle destroying context. >- context.release().leakRef(); >-} >- >-void WorkQueue::unregisterWaitAndDestroyItemSoon(PassRefPtr<HandleWorkItem> item) >-{ >- // We're going to make a blocking call to ::UnregisterWaitEx before closing the handle. (The >- // blocking version of ::UnregisterWaitEx is much simpler than the non-blocking version.) If we >- // do this on the current thread, we'll deadlock if we're currently in a callback function for >- // the wait we're unregistering. So instead we do it asynchronously on some other worker thread. >- >- ::QueueUserWorkItem(unregisterWaitAndDestroyItemCallback, item.leakRef(), WT_EXECUTEDEFAULT); >-} >- >-DWORD WINAPI WorkQueue::unregisterWaitAndDestroyItemCallback(void* context) >-{ >- ASSERT_ARG(context, context); >- RefPtr<HandleWorkItem> item = adoptRef(static_cast<HandleWorkItem*>(context)); >- >- // Now that we know we're not in a callback function for the wait we're unregistering, we can >- // make a blocking call to ::UnregisterWaitEx. >- if (!::UnregisterWaitEx(item->waitHandle(), INVALID_HANDLE_VALUE)) { >- DWORD error = ::GetLastError(); >- ASSERT_NOT_REACHED(); >- } >- >- return 0; >-} >diff --git a/Source/WebKit2/PlatformEfl.cmake b/Source/WebKit2/PlatformEfl.cmake >index 7d06184c1bb9ddeb6a75eee23ec75c7b97c8abd5..f9b336332c5d13d70f446ba892702872f0b5b291 100644 >--- a/Source/WebKit2/PlatformEfl.cmake >+++ b/Source/WebKit2/PlatformEfl.cmake >@@ -8,7 +8,6 @@ LIST(APPEND WebKit2_LINK_FLAGS > > LIST(APPEND WebKit2_SOURCES > Platform/efl/ModuleEfl.cpp >- Platform/efl/WorkQueueEfl.cpp > Platform/unix/SharedMemoryUnix.cpp > > Platform/CoreIPC/unix/ConnectionUnix.cpp >diff --git a/Source/WebKit2/Target.pri b/Source/WebKit2/Target.pri >index 25d894f7ea8429ec6975b6c21956395e2c85b748..b5cd9309a6f53a444a78b70fe9b2c65ee4bbe004 100644 >--- a/Source/WebKit2/Target.pri >+++ b/Source/WebKit2/Target.pri >@@ -30,9 +30,7 @@ HEADERS += \ > Platform/CoreIPC/MessageSender.h \ > Platform/Logging.h \ > Platform/Module.h \ >- Platform/PlatformProcessIdentifier.h \ > Platform/SharedMemory.h \ >- Platform/WorkQueue.h \ > PluginProcess/PluginControllerProxy.h \ > PluginProcess/PluginCreationParameters.h \ > PluginProcess/PluginProcess.h \ >@@ -410,7 +408,6 @@ SOURCES += \ > Platform/CoreIPC/DataReference.cpp \ > Platform/Logging.cpp \ > Platform/Module.cpp \ >- Platform/WorkQueue.cpp \ > Platform/qt/LoggingQt.cpp \ > Platform/qt/ModuleQt.cpp \ > PluginProcess/PluginControllerProxy.cpp \ >@@ -821,14 +818,12 @@ mac: { > SOURCES += \ > Platform/CoreIPC/mac/ConnectionMac.cpp \ > Platform/mac/MachUtilities.cpp \ >- Platform/mac/WorkQueueMac.cpp \ > Platform/mac/SharedMemoryMac.cpp > > } else { > SOURCES += \ > Platform/CoreIPC/unix/AttachmentUnix.cpp \ > Platform/CoreIPC/unix/ConnectionUnix.cpp \ >- Platform/qt/WorkQueueQt.cpp \ > Platform/unix/SharedMemoryUnix.cpp > } > >diff --git a/Source/WebKit2/UIProcess/Launcher/ProcessLauncher.cpp b/Source/WebKit2/UIProcess/Launcher/ProcessLauncher.cpp >index ba22dda2da7bc5b48d335869afa380c7bb36829e..67def76821fa0b50dafe9b9ce5168c5efd980334 100644 >--- a/Source/WebKit2/UIProcess/Launcher/ProcessLauncher.cpp >+++ b/Source/WebKit2/UIProcess/Launcher/ProcessLauncher.cpp >@@ -26,8 +26,8 @@ > #include "config.h" > #include "ProcessLauncher.h" > >-#include "WorkQueue.h" > #include <wtf/StdLibExtras.h> >+#include <wtf/WorkQueue.h> > > namespace WebKit { > >diff --git a/Source/WebKit2/UIProcess/Launcher/ProcessLauncher.h b/Source/WebKit2/UIProcess/Launcher/ProcessLauncher.h >index bc1f867f3c2915523630c67611f05ce973ded53b..d61bd79dbdb0c18762d1f2700167cae3aed8f931 100644 >--- a/Source/WebKit2/UIProcess/Launcher/ProcessLauncher.h >+++ b/Source/WebKit2/UIProcess/Launcher/ProcessLauncher.h >@@ -27,7 +27,7 @@ > #define WebProcessLauncher_h > > #include "Connection.h" >-#include "PlatformProcessIdentifier.h" >+#include <wtf/PlatformProcessIdentifier.h> > #include <wtf/RefPtr.h> > #include <wtf/Threading.h> > >diff --git a/Source/WebKit2/UIProcess/Launcher/ThreadLauncher.h b/Source/WebKit2/UIProcess/Launcher/ThreadLauncher.h >index f3a5312a2c4f77ebf20fd2c48966f35acb0ad8d1..9c6b12496f0e356bee2ab5d685953e6d16aad2bc 100644 >--- a/Source/WebKit2/UIProcess/Launcher/ThreadLauncher.h >+++ b/Source/WebKit2/UIProcess/Launcher/ThreadLauncher.h >@@ -27,7 +27,7 @@ > #define ThreadLauncher_h > > #include "Connection.h" >-#include "PlatformProcessIdentifier.h" >+#include <wtf/PlatformProcessIdentifier.h> > #include <wtf/RefPtr.h> > #include <wtf/Threading.h> > >diff --git a/Source/WebKit2/UIProcess/WebPageProxy.h b/Source/WebKit2/UIProcess/WebPageProxy.h >index 57ab86c24293b1ad2222412eb58e9a9f56c8c548..0e95be54b7a1aeea50043bcf7543cf1b17362591 100644 >--- a/Source/WebKit2/UIProcess/WebPageProxy.h >+++ b/Source/WebKit2/UIProcess/WebPageProxy.h >@@ -40,7 +40,6 @@ > #endif > #include "LayerTreeContext.h" > #include "NotificationPermissionRequestManagerProxy.h" >-#include "PlatformProcessIdentifier.h" > #include "SandboxExtension.h" > #include "ShareableBitmap.h" > #include "WKBase.h" >@@ -73,6 +72,7 @@ > #include <wtf/OwnPtr.h> > #include <wtf/PassOwnPtr.h> > #include <wtf/PassRefPtr.h> >+#include <wtf/PlatformProcessIdentifier.h> > #include <wtf/RefPtr.h> > #include <wtf/Vector.h> > #include <wtf/text/WTFString.h> >diff --git a/Source/WebKit2/UIProcess/WebProcessProxy.h b/Source/WebKit2/UIProcess/WebProcessProxy.h >index 8e768bfb6a889d9ad6b360007694b25676cea686..6419a7a3538c61fe8d4579c306d234b655ddc122 100644 >--- a/Source/WebKit2/UIProcess/WebProcessProxy.h >+++ b/Source/WebKit2/UIProcess/WebProcessProxy.h >@@ -26,7 +26,6 @@ > #ifndef WebProcessProxy_h > #define WebProcessProxy_h > >-#include "PlatformProcessIdentifier.h" > #include "PluginInfoStore.h" > #include "ProcessLauncher.h" > #include "ProcessModel.h" >@@ -39,6 +38,7 @@ > #include <wtf/Forward.h> > #include <wtf/HashMap.h> > #include <wtf/PassRefPtr.h> >+#include <wtf/PlatformProcessIdentifier.h> > #include <wtf/RefCounted.h> > > namespace WebCore { >diff --git a/Source/WebKit2/WebKit2.xcodeproj/project.pbxproj b/Source/WebKit2/WebKit2.xcodeproj/project.pbxproj >index 6077f6d3e38a45101238b542378cc287e04dbaf0..ead478a6840844f2aead3f66403faa2191cc0b00 100644 >--- a/Source/WebKit2/WebKit2.xcodeproj/project.pbxproj >+++ b/Source/WebKit2/WebKit2.xcodeproj/project.pbxproj >@@ -476,7 +476,6 @@ > B63403F914910D57001070B5 /* APIObject.cpp in Sources */ = {isa = PBXBuildFile; fileRef = B63403F814910D57001070B5 /* APIObject.cpp */; }; > B878B615133428DC006888E9 /* CorrectionPanel.h in Headers */ = {isa = PBXBuildFile; fileRef = B878B613133428DC006888E9 /* CorrectionPanel.h */; }; > B878B616133428DC006888E9 /* CorrectionPanel.mm in Sources */ = {isa = PBXBuildFile; fileRef = B878B614133428DC006888E9 /* CorrectionPanel.mm */; }; >- BC0092F8115837A300E0AE2A /* WorkQueueMac.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BC0092F6115837A300E0AE2A /* WorkQueueMac.cpp */; }; > BC032D7510F4378D0058C15A /* WebChromeClient.h in Headers */ = {isa = PBXBuildFile; fileRef = BC032D6010F4378D0058C15A /* WebChromeClient.h */; }; > BC032D7710F4378D0058C15A /* WebContextMenuClient.h in Headers */ = {isa = PBXBuildFile; fileRef = BC032D6210F4378D0058C15A /* WebContextMenuClient.h */; }; > BC032D7B10F4378D0058C15A /* WebDragClient.h in Headers */ = {isa = PBXBuildFile; fileRef = BC032D6610F4378D0058C15A /* WebDragClient.h */; }; >@@ -569,8 +568,6 @@ > BC2D021712AC41CB00E732A3 /* SameDocumentNavigationType.h in Headers */ = {isa = PBXBuildFile; fileRef = BC2D021612AC41CB00E732A3 /* SameDocumentNavigationType.h */; }; > BC2D021912AC426C00E732A3 /* WKPageLoadTypes.h in Headers */ = {isa = PBXBuildFile; fileRef = BC2D021812AC426C00E732A3 /* WKPageLoadTypes.h */; settings = {ATTRIBUTES = (Private, ); }; }; > BC2DFBA312A761A500E732A3 /* WebPreferencesCF.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BC2DFBA212A761A500E732A3 /* WebPreferencesCF.cpp */; }; >- BC2E6E8D1141971500A63B1E /* WorkQueue.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BC2E6E7D1141970C00A63B1E /* WorkQueue.cpp */; }; >- BC2E6E8E1141971500A63B1E /* WorkQueue.h in Headers */ = {isa = PBXBuildFile; fileRef = BC2E6E7E1141970C00A63B1E /* WorkQueue.h */; }; > BC3065C412592F8900E71278 /* WebProcessMac.mm in Sources */ = {isa = PBXBuildFile; fileRef = BC3065C312592F8900E71278 /* WebProcessMac.mm */; }; > BC3065FA1259344E00E71278 /* CacheModel.h in Headers */ = {isa = PBXBuildFile; fileRef = BC3065F91259344E00E71278 /* CacheModel.h */; }; > BC3066BE125A442100E71278 /* WebProcessMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BC3066BC125A442100E71278 /* WebProcessMessageReceiver.cpp */; }; >@@ -1514,7 +1511,6 @@ > B63403F814910D57001070B5 /* APIObject.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = APIObject.cpp; sourceTree = "<group>"; }; > B878B613133428DC006888E9 /* CorrectionPanel.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CorrectionPanel.h; sourceTree = "<group>"; }; > B878B614133428DC006888E9 /* CorrectionPanel.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = CorrectionPanel.mm; sourceTree = "<group>"; }; >- BC0092F6115837A300E0AE2A /* WorkQueueMac.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WorkQueueMac.cpp; sourceTree = "<group>"; }; > BC032D6010F4378D0058C15A /* WebChromeClient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebChromeClient.h; sourceTree = "<group>"; }; > BC032D6210F4378D0058C15A /* WebContextMenuClient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebContextMenuClient.h; sourceTree = "<group>"; }; > BC032D6610F4378D0058C15A /* WebDragClient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebDragClient.h; sourceTree = "<group>"; }; >@@ -1613,8 +1609,6 @@ > BC2D021612AC41CB00E732A3 /* SameDocumentNavigationType.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SameDocumentNavigationType.h; sourceTree = "<group>"; }; > BC2D021812AC426C00E732A3 /* WKPageLoadTypes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WKPageLoadTypes.h; sourceTree = "<group>"; }; > BC2DFBA212A761A500E732A3 /* WebPreferencesCF.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = WebPreferencesCF.cpp; path = cf/WebPreferencesCF.cpp; sourceTree = "<group>"; }; >- BC2E6E7D1141970C00A63B1E /* WorkQueue.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WorkQueue.cpp; sourceTree = "<group>"; }; >- BC2E6E7E1141970C00A63B1E /* WorkQueue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WorkQueue.h; sourceTree = "<group>"; }; > BC3065C312592F8900E71278 /* WebProcessMac.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WebProcessMac.mm; sourceTree = "<group>"; }; > BC3065F91259344E00E71278 /* CacheModel.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CacheModel.h; sourceTree = "<group>"; }; > BC3066B9125A436300E71278 /* WebProcess.messages.in */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = WebProcess.messages.in; sourceTree = "<group>"; }; >@@ -2298,7 +2292,6 @@ > 1A24BF39120896A600FBB059 /* SharedMemoryMac.cpp */, > 296BD85B15019BC30071F424 /* StringUtilities.h */, > 296BD85C15019BC30071F424 /* StringUtilities.mm */, >- BC0092F6115837A300E0AE2A /* WorkQueueMac.cpp */, > ); > path = mac; > sourceTree = "<group>"; >@@ -3336,8 +3329,6 @@ > C0E3AA441209E2BA00A49D01 /* Module.h */, > BC8780FB1161C2B800CC2768 /* PlatformProcessIdentifier.h */, > 1A24BED3120894D100FBB059 /* SharedMemory.h */, >- BC2E6E7D1141970C00A63B1E /* WorkQueue.cpp */, >- BC2E6E7E1141970C00A63B1E /* WorkQueue.h */, > ); > path = Platform; > sourceTree = "<group>"; >@@ -4189,7 +4180,6 @@ > BC8699B5116AADAA002A925B /* WKView.h in Headers */, > BC8699B7116AADAA002A925B /* WKViewInternal.h in Headers */, > BFA6179F12F0B99D0033E0CA /* WKViewPrivate.h in Headers */, >- BC2E6E8E1141971500A63B1E /* WorkQueue.h in Headers */, > E17BF99614D0A73E00A5A069 /* NetscapeSandboxFunctions.h in Headers */, > BCE0937814FB128C001138D9 /* LayerHostingContext.h in Headers */, > 296BD85D15019BC30071F424 /* StringUtilities.h in Headers */, >@@ -4936,8 +4926,6 @@ > BC40762C124FF0400068F20A /* WKURLResponseNS.mm in Sources */, > F6113E28126CE19B0057D0A7 /* WKUserContentURLPattern.cpp in Sources */, > BC8699B6116AADAA002A925B /* WKView.mm in Sources */, >- BC2E6E8D1141971500A63B1E /* WorkQueue.cpp in Sources */, >- BC0092F8115837A300E0AE2A /* WorkQueueMac.cpp in Sources */, > E17BF99814D0AA8300A5A069 /* NetscapeSandboxFunctions.mm in Sources */, > BCE0937714FB128C001138D9 /* LayerHostingContext.mm in Sources */, > 296BD85E15019BC30071F424 /* StringUtilities.mm in Sources */, >diff --git a/Source/WebKit2/win/WebKit2.vcproj b/Source/WebKit2/win/WebKit2.vcproj >index 0a38c4b822a824798ff8c4ee2f3cd2489b7b6d0f..37252b614382769cf2bae6fa5a3036d33a0325e4 100755 >--- a/Source/WebKit2/win/WebKit2.vcproj >+++ b/Source/WebKit2/win/WebKit2.vcproj >@@ -3934,14 +3934,6 @@ > RelativePath="..\Platform\SharedMemory.h" > > > </File> >- <File >- RelativePath="..\Platform\WorkQueue.cpp" >- > >- </File> >- <File >- RelativePath="..\Platform\WorkQueue.h" >- > >- </File> > <Filter > Name="cg" > > >@@ -3981,10 +3973,6 @@ > RelativePath="..\Platform\win\SharedMemoryWin.cpp" > > > </File> >- <File >- RelativePath="..\Platform\win\WorkQueueWin.cpp" >- > >- </File> > </Filter> > <Filter > Name="CoreIPC"
<b>You cannot view the attachment while viewing its details because your browser does not support IFRAMEs. <a href="attachment.cgi?id=151643">View the attachment on a separate page</a>.</b>
View Attachment As Diff
View Attachment As Raw
Actions:
View
|
Formatted Diff
|
Diff
Attachments on
bug 90780
:
151238
|
151240
|
151241
|
151242
|
151627
|
151643
|
154508