widget/nsBaseAppShell.cpp

   1 /* -*- Mode: c++; tab-width: 2; indent-tabs-mode: nil; -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "base/message_loop.h"
   7
   8 #include "nsBaseAppShell.h"
   9 #include "nsExceptionHandler.h"
  10 #include "nsThreadUtils.h"
  11 #include "nsIObserverService.h"
  12 #include "nsServiceManagerUtils.h"
  13 #include "mozilla/Services.h"
  14 #include "nsXULAppAPI.h"
  15
  16 // When processing the next thread event, the appshell may process native
  17 // events (if not in performance mode), which can result in suppressing the
  18 // next thread event for at most this many ticks:
  19 #define THREAD_EVENT_STARVATION_LIMIT PR_MillisecondsToInterval(10)
  20
  21 NS_IMPL_ISUPPORTS(nsBaseAppShell, nsIAppShell, nsIThreadObserver, nsIObserver)
  22
  23 nsBaseAppShell::nsBaseAppShell()
  24   : mSuspendNativeCount(0)
  25   , mEventloopNestingLevel(0)
  26   , mBlockedWait(nullptr)
  27   , mFavorPerf(0)
  28   , mNativeEventPending(false)
  29   , mStarvationDelay(0)
  30   , mSwitchTime(0)
  31   , mLastNativeEventTime(0)
  32   , mEventloopNestingState(eEventloopNone)
  33   , mRunning(false)
  34   , mExiting(false)
  35   , mBlockNativeEvent(false)
  36   , mProcessedGeckoEvents(false)
  37 {
  38 }
  39
  40 nsBaseAppShell::~nsBaseAppShell()
  41 {
  42 }
  43
  44 nsresult
  45 nsBaseAppShell::Init()
  46 {
  47   // Configure ourselves as an observer for the current thread:
  48
  49   if (XRE_UseNativeEventProcessing()) {
  50     nsCOMPtr<nsIThreadInternal> threadInt =
  51       do_QueryInterface(NS_GetCurrentThread());
  52     NS_ENSURE_STATE(threadInt);
  53
  54     threadInt->SetObserver(this);
  55   }
  56
  57   nsCOMPtr<nsIObserverService> obsSvc =
  58     mozilla::services::GetObserverService();
  59   if (obsSvc)
  60     obsSvc->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false);
  61   return NS_OK;
  62 }
  63
  64 // Called by nsAppShell's native event callback
  65 void
  66 nsBaseAppShell::NativeEventCallback()
  67 {
  68   if (!mNativeEventPending.exchange(false))
  69     return;
  70
  71   // If DoProcessNextNativeEvent is on the stack, then we assume that we can
  72   // just unwind and let nsThread::ProcessNextEvent process the next event.
  73   // However, if we are called from a nested native event loop (maybe via some
  74   // plug-in or library function), then go ahead and process Gecko events now.
  75   if (mEventloopNestingState == eEventloopXPCOM) {
  76     mEventloopNestingState = eEventloopOther;
  77     // XXX there is a tiny risk we will never get a new NativeEventCallback,
  78     // XXX see discussion in bug 389931.
  79     return;
  80   }
  81
  82   // nsBaseAppShell::Run is not being used to pump events, so this may be
  83   // our only opportunity to process pending gecko events.
  84
  85   nsIThread *thread = NS_GetCurrentThread();
  86   bool prevBlockNativeEvent = mBlockNativeEvent;
  87   if (mEventloopNestingState == eEventloopOther) {
  88     if (!NS_HasPendingEvents(thread))
  89       return;
  90     // We're in a nested native event loop and have some gecko events to
  91     // process.  While doing that we block processing native events from the
  92     // appshell - instead, we want to get back to the nested native event
  93     // loop ASAP (bug 420148).
  94     mBlockNativeEvent = true;
  95   }
  96
  97   IncrementEventloopNestingLevel();
  98   EventloopNestingState prevVal = mEventloopNestingState;
  99   NS_ProcessPendingEvents(thread, THREAD_EVENT_STARVATION_LIMIT);
 100   mProcessedGeckoEvents = true;
 101   mEventloopNestingState = prevVal;
 102   mBlockNativeEvent = prevBlockNativeEvent;
 103
 104   // Continue processing pending events later (we don't want to starve the
 105   // embedders event loop).
 106   if (NS_HasPendingEvents(thread))
 107     DoProcessMoreGeckoEvents();
 108
 109   DecrementEventloopNestingLevel();
 110 }
 111
 112 // Note, this is currently overidden on windows, see comments in nsAppShell for
 113 // details.
 114 void
 115 nsBaseAppShell::DoProcessMoreGeckoEvents()
 116 {
 117   OnDispatchedEvent();
 118 }
 119
 120
 121 // Main thread via OnProcessNextEvent below
 122 bool
 123 nsBaseAppShell::DoProcessNextNativeEvent(bool mayWait)
 124 {
 125   // The next native event to be processed may trigger our NativeEventCallback,
 126   // in which case we do not want it to process any thread events since we'll
 127   // do that when this function returns.
 128   //
 129   // If the next native event is not our NativeEventCallback, then we may end
 130   // up recursing into this function.
 131   //
 132   // However, if the next native event is not our NativeEventCallback, but it
 133   // results in another native event loop, then our NativeEventCallback could
 134   // fire and it will see mEventloopNestingState as eEventloopOther.
 135   //
 136   EventloopNestingState prevVal = mEventloopNestingState;
 137   mEventloopNestingState = eEventloopXPCOM;
 138
 139   IncrementEventloopNestingLevel();
 140   bool result = ProcessNextNativeEvent(mayWait);
 141   DecrementEventloopNestingLevel();
 142
 143   mEventloopNestingState = prevVal;
 144   return result;
 145 }
 146
 147 //-------------------------------------------------------------------------
 148 // nsIAppShell methods:
 149
 150 NS_IMETHODIMP
 151 nsBaseAppShell::Run(void)
 152 {
 153   NS_ENSURE_STATE(!mRunning);  // should not call Run twice
 154   mRunning = true;
 155
 156   nsIThread *thread = NS_GetCurrentThread();
 157
 158   MessageLoop::current()->Run();
 159
 160   NS_ProcessPendingEvents(thread);
 161
 162   mRunning = false;
 163   return NS_OK;
 164 }
 165
 166 NS_IMETHODIMP
 167 nsBaseAppShell::Exit(void)
 168 {
 169   if (mRunning && !mExiting) {
 170     MessageLoop::current()->Quit();
 171   }
 172   mExiting = true;
 173   return NS_OK;
 174 }
 175
 176 NS_IMETHODIMP
 177 nsBaseAppShell::FavorPerformanceHint(bool favorPerfOverStarvation,
 178                                      uint32_t starvationDelay)
 179 {
 180   mStarvationDelay = PR_MillisecondsToInterval(starvationDelay);
 181   if (favorPerfOverStarvation) {
 182     ++mFavorPerf;
 183   } else {
 184     --mFavorPerf;
 185     mSwitchTime = PR_IntervalNow();
 186   }
 187   return NS_OK;
 188 }
 189
 190 NS_IMETHODIMP
 191 nsBaseAppShell::SuspendNative()
 192 {
 193   ++mSuspendNativeCount;
 194   return NS_OK;
 195 }
 196
 197 NS_IMETHODIMP
 198 nsBaseAppShell::ResumeNative()
 199 {
 200   --mSuspendNativeCount;
 201   NS_ASSERTION(mSuspendNativeCount >= 0, "Unbalanced call to nsBaseAppShell::ResumeNative!");
 202   return NS_OK;
 203 }
 204
 205 NS_IMETHODIMP
 206 nsBaseAppShell::GetEventloopNestingLevel(uint32_t* aNestingLevelResult)
 207 {
 208   NS_ENSURE_ARG_POINTER(aNestingLevelResult);
 209
 210   *aNestingLevelResult = mEventloopNestingLevel;
 211
 212   return NS_OK;
 213 }
 214
 215 //-------------------------------------------------------------------------
 216 // nsIThreadObserver methods:
 217
 218 // Called from any thread
 219 NS_IMETHODIMP
 220 nsBaseAppShell::OnDispatchedEvent()
 221 {
 222   if (mBlockNativeEvent)
 223     return NS_OK;
 224
 225   if (mNativeEventPending.exchange(true))
 226     return NS_OK;
 227
 228   // Returns on the main thread in NativeEventCallback above
 229   ScheduleNativeEventCallback();
 230   return NS_OK;
 231 }
 232
 233 // Called from the main thread
 234 NS_IMETHODIMP
 235 nsBaseAppShell::OnProcessNextEvent(nsIThreadInternal *thr, bool mayWait)
 236 {
 237   if (mBlockNativeEvent) {
 238     if (!mayWait)
 239       return NS_OK;
 240     // Hmm, we're in a nested native event loop and would like to get
 241     // back to it ASAP, but it seems a gecko event has caused us to
 242     // spin up a nested XPCOM event loop (eg. modal window), so we
 243     // really must start processing native events here again.
 244     mBlockNativeEvent = false;
 245     if (NS_HasPendingEvents(thr))
 246       OnDispatchedEvent(); // in case we blocked it earlier
 247   }
 248
 249   PRIntervalTime start = PR_IntervalNow();
 250   PRIntervalTime limit = THREAD_EVENT_STARVATION_LIMIT;
 251
 252   // Unblock outer nested wait loop (below).
 253   if (mBlockedWait)
 254     *mBlockedWait = false;
 255
 256   bool *oldBlockedWait = mBlockedWait;
 257   mBlockedWait = &mayWait;
 258
 259   // When mayWait is true, we need to make sure that there is an event in the
 260   // thread's event queue before we return.  Otherwise, the thread will block
 261   // on its event queue waiting for an event.
 262   bool needEvent = mayWait;
 263   // Reset prior to invoking DoProcessNextNativeEvent which might cause
 264   // NativeEventCallback to process gecko events.
 265   mProcessedGeckoEvents = false;
 266
 267   if (mFavorPerf <= 0 && start > mSwitchTime + mStarvationDelay) {
 268     // Favor pending native events
 269     PRIntervalTime now = start;
 270     bool keepGoing;
 271     do {
 272       mLastNativeEventTime = now;
 273       keepGoing = DoProcessNextNativeEvent(false);
 274     } while (keepGoing && ((now = PR_IntervalNow()) - start) < limit);
 275   } else {
 276     // Avoid starving native events completely when in performance mode
 277     if (start - mLastNativeEventTime > limit) {
 278       mLastNativeEventTime = start;
 279       DoProcessNextNativeEvent(false);
 280     }
 281   }
 282
 283   while (!NS_HasPendingEvents(thr) && !mProcessedGeckoEvents) {
 284     // If we have been asked to exit from Run, then we should not wait for
 285     // events to process.  Note that an inner nested event loop causes
 286     // 'mayWait' to become false too, through 'mBlockedWait'.
 287     if (mExiting)
 288       mayWait = false;
 289
 290     mLastNativeEventTime = PR_IntervalNow();
 291     if (!DoProcessNextNativeEvent(mayWait) || !mayWait)
 292       break;
 293   }
 294
 295   mBlockedWait = oldBlockedWait;
 296
 297   // Make sure that the thread event queue does not block on its monitor, as
 298   // it normally would do if it did not have any pending events.  To avoid
 299   // that, we simply insert a dummy event into its queue during shutdown.
 300   if (needEvent && !mExiting && !NS_HasPendingEvents(thr)) {
 301     DispatchDummyEvent(thr);
 302   }
 303
 304   return NS_OK;
 305 }
 306
 307 bool
 308 nsBaseAppShell::DispatchDummyEvent(nsIThread* aTarget)
 309 {
 310   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 311
 312   if (!mDummyEvent)
 313     mDummyEvent = new mozilla::Runnable("DummyEvent");
 314
 315   return NS_SUCCEEDED(aTarget->Dispatch(mDummyEvent, NS_DISPATCH_NORMAL));
 316 }
 317
 318 void
 319 nsBaseAppShell::IncrementEventloopNestingLevel()
 320 {
 321   ++mEventloopNestingLevel;
 322   CrashReporter::SetEventloopNestingLevel(mEventloopNestingLevel);
 323 }
 324
 325 void
 326 nsBaseAppShell::DecrementEventloopNestingLevel()
 327 {
 328   --mEventloopNestingLevel;
 329   CrashReporter::SetEventloopNestingLevel(mEventloopNestingLevel);
 330 }
 331
 332 // Called from the main thread
 333 NS_IMETHODIMP
 334 nsBaseAppShell::AfterProcessNextEvent(nsIThreadInternal *thr,
 335                                       bool eventWasProcessed)
 336 {
 337   return NS_OK;
 338 }
 339
 340 NS_IMETHODIMP
 341 nsBaseAppShell::Observe(nsISupports *subject, const char *topic,
 342                         const char16_t *data)
 343 {
 344   NS_ASSERTION(!strcmp(topic, NS_XPCOM_SHUTDOWN_OBSERVER_ID), "oops");
 345   Exit();
 346   return NS_OK;
 347 }