wtf/MainThread.cpp

   1 /*
   2  * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  * 1.  Redistributions of source code must retain the above copyright
   9  *     notice, this list of conditions and the following disclaimer.
  10  * 2.  Redistributions in binary form must reproduce the above copyright
  11  *     notice, this list of conditions and the following disclaimer in the
  12  *     documentation and/or other materials provided with the distribution.
  13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
  14  *     its contributors may be used to endorse or promote products derived
  15  *     from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include "config.h"
  30 #include "MainThread.h"
  31
  32 #include "CurrentTime.h"
  33 #include "Deque.h"
  34 #include "StdLibExtras.h"
  35 #include "Threading.h"
  36
  37 #include <wtf/iphone/WebCoreThread.h>
  38
  39 #if PLATFORM(CHROMIUM)
  40 #error Chromium uses a different main thread implementation
  41 #endif
  42
  43 namespace WTF {
  44
  45 struct FunctionWithContext {
  46     MainThreadFunction* function;
  47     void* context;
  48     ThreadCondition* syncFlag;
  49
  50     FunctionWithContext(MainThreadFunction* function = 0, void* context = 0, ThreadCondition* syncFlag = 0)
  51         : function(function)
  52         , context(context)
  53         , syncFlag(syncFlag)
  54     {
  55     }
  56     bool operator == (const FunctionWithContext& o)
  57     {
  58         return function == o.function
  59             && context == o.context
  60             && syncFlag == o.syncFlag;
  61     }
  62 };
  63
  64 class FunctionWithContextFinder {
  65 public:
  66     FunctionWithContextFinder(const FunctionWithContext& m) : m(m) {}
  67     bool operator() (FunctionWithContext& o) { return o == m; }
  68     FunctionWithContext m;
  69 };
  70
  71
  72 typedef Deque<FunctionWithContext> FunctionQueue;
  73
  74 static bool callbacksPaused; // This global variable is only accessed from main thread.
  75 #if !PLATFORM(MAC) && !PLATFORM(QT)
  76 static ThreadIdentifier mainThreadIdentifier;
  77 #endif
  78
  79 static Mutex& mainThreadFunctionQueueMutex()
  80 {
  81     DEFINE_STATIC_LOCAL(Mutex, staticMutex, ());
  82     return staticMutex;
  83 }
  84
  85 static FunctionQueue& functionQueue()
  86 {
  87     DEFINE_STATIC_LOCAL(FunctionQueue, staticFunctionQueue, ());
  88     return staticFunctionQueue;
  89 }
  90
  91
  92 #if !PLATFORM(MAC)
  93
  94 void initializeMainThread()
  95 {
  96     static bool initializedMainThread;
  97     if (initializedMainThread)
  98         return;
  99     initializedMainThread = true;
 100
 101 #if !PLATFORM(QT)
 102     mainThreadIdentifier = currentThread();
 103 #endif
 104
 105     mainThreadFunctionQueueMutex();
 106     initializeMainThreadPlatform();
 107 }
 108
 109 #else
 110
 111 static pthread_once_t initializeMainThreadKeyOnce = PTHREAD_ONCE_INIT;
 112
 113 static void initializeMainThreadOnce()
 114 {
 115     mainThreadFunctionQueueMutex();
 116     initializeMainThreadPlatform();
 117 }
 118
 119 void initializeMainThread()
 120 {
 121     pthread_once(&initializeMainThreadKeyOnce, initializeMainThreadOnce);
 122 }
 123
 124 static void initializeMainThreadToProcessMainThreadOnce()
 125 {
 126     mainThreadFunctionQueueMutex();
 127     initializeMainThreadToProcessMainThreadPlatform();
 128 }
 129
 130 void initializeMainThreadToProcessMainThread()
 131 {
 132     pthread_once(&initializeMainThreadKeyOnce, initializeMainThreadToProcessMainThreadOnce);
 133 }
 134 #endif
 135
 136 // 0.1 sec delays in UI is approximate threshold when they become noticeable. Have a limit that's half of that.
 137 static const double maxRunLoopSuspensionTime = 0.05;
 138
 139 void dispatchFunctionsFromMainThread()
 140 {
 141     ASSERT(isMainThread());
 142
 143     if (callbacksPaused)
 144         return;
 145
 146     double startTime = currentTime();
 147
 148     FunctionWithContext invocation;
 149     while (true) {
 150         {
 151             MutexLocker locker(mainThreadFunctionQueueMutex());
 152             if (!functionQueue().size())
 153                 break;
 154             invocation = functionQueue().takeFirst();
 155         }
 156
 157         invocation.function(invocation.context);
 158         if (invocation.syncFlag) {
 159             MutexLocker locker(mainThreadFunctionQueueMutex());
 160             invocation.syncFlag->signal();
 161         }
 162
 163         // If we are running accumulated functions for too long so UI may become unresponsive, we need to
 164         // yield so the user input can be processed. Otherwise user may not be able to even close the window.
 165         // This code has effect only in case the scheduleDispatchFunctionsOnMainThread() is implemented in a way that
 166         // allows input events to be processed before we are back here.
 167         if (currentTime() - startTime > maxRunLoopSuspensionTime) {
 168             scheduleDispatchFunctionsOnMainThread();
 169             break;
 170         }
 171     }
 172 }
 173
 174 void callOnMainThread(MainThreadFunction* function, void* context)
 175 {
 176     ASSERT(function);
 177     bool needToSchedule = false;
 178     {
 179         MutexLocker locker(mainThreadFunctionQueueMutex());
 180         needToSchedule = functionQueue().size() == 0;
 181         functionQueue().append(FunctionWithContext(function, context));
 182     }
 183     if (needToSchedule)
 184         scheduleDispatchFunctionsOnMainThread();
 185 }
 186
 187 void callOnMainThreadAndWait(MainThreadFunction* function, void* context)
 188 {
 189     ASSERT(function);
 190
 191     if (isMainThread()) {
 192         function(context);
 193         return;
 194     }
 195
 196     ThreadCondition syncFlag;
 197     Mutex& functionQueueMutex = mainThreadFunctionQueueMutex();
 198     MutexLocker locker(functionQueueMutex);
 199     functionQueue().append(FunctionWithContext(function, context, &syncFlag));
 200     if (functionQueue().size() == 1)
 201         scheduleDispatchFunctionsOnMainThread();
 202     syncFlag.wait(functionQueueMutex);
 203 }
 204
 205 void cancelCallOnMainThread(MainThreadFunction* function, void* context)
 206 {
 207     ASSERT(function);
 208
 209     MutexLocker locker(mainThreadFunctionQueueMutex());
 210
 211     FunctionWithContextFinder pred(FunctionWithContext(function, context));
 212
 213     while (true) {
 214         // We must redefine 'i' each pass, because the itererator's operator=
 215         // requires 'this' to be valid, and remove() invalidates all iterators
 216         FunctionQueue::iterator i(functionQueue().findIf(pred));
 217         if (i == functionQueue().end())
 218             break;
 219         functionQueue().remove(i);
 220     }
 221 }
 222
 223 void setMainThreadCallbacksPaused(bool paused)
 224 {
 225     ASSERT((isMainThread() || pthread_main_np()) && WebCoreWebThreadIsLockedOrDisabled());
 226
 227     if (callbacksPaused == paused)
 228         return;
 229
 230     callbacksPaused = paused;
 231
 232     if (!callbacksPaused)
 233         scheduleDispatchFunctionsOnMainThread();
 234 }
 235
 236 #if !PLATFORM(MAC) && !PLATFORM(QT) && !PLATFORM(BREWMP)
 237 bool isMainThread()
 238 {
 239     return currentThread() == mainThreadIdentifier;
 240 }
 241 #endif
 242
 243 } // namespace WTF