From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- widget/nsBaseAppShell.cpp | 349 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 349 insertions(+) create mode 100644 widget/nsBaseAppShell.cpp (limited to 'widget/nsBaseAppShell.cpp') diff --git a/widget/nsBaseAppShell.cpp b/widget/nsBaseAppShell.cpp new file mode 100644 index 000000000..1557498b7 --- /dev/null +++ b/widget/nsBaseAppShell.cpp @@ -0,0 +1,349 @@ +/* -*- Mode: c++; tab-width: 2; indent-tabs-mode: nil; -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "base/message_loop.h" + +#include "nsBaseAppShell.h" +#if defined(MOZ_CRASHREPORTER) +#include "nsExceptionHandler.h" +#endif +#include "nsThreadUtils.h" +#include "nsIObserverService.h" +#include "nsServiceManagerUtils.h" +#include "mozilla/Services.h" + +// When processing the next thread event, the appshell may process native +// events (if not in performance mode), which can result in suppressing the +// next thread event for at most this many ticks: +#define THREAD_EVENT_STARVATION_LIMIT PR_MillisecondsToInterval(10) + +NS_IMPL_ISUPPORTS(nsBaseAppShell, nsIAppShell, nsIThreadObserver, nsIObserver) + +nsBaseAppShell::nsBaseAppShell() + : mSuspendNativeCount(0) + , mEventloopNestingLevel(0) + , mBlockedWait(nullptr) + , mFavorPerf(0) + , mNativeEventPending(false) + , mStarvationDelay(0) + , mSwitchTime(0) + , mLastNativeEventTime(0) + , mEventloopNestingState(eEventloopNone) + , mRunning(false) + , mExiting(false) + , mBlockNativeEvent(false) +{ +} + +nsBaseAppShell::~nsBaseAppShell() +{ +} + +nsresult +nsBaseAppShell::Init() +{ + // Configure ourselves as an observer for the current thread: + + nsCOMPtr threadInt = + do_QueryInterface(NS_GetCurrentThread()); + NS_ENSURE_STATE(threadInt); + + threadInt->SetObserver(this); + + nsCOMPtr obsSvc = + mozilla::services::GetObserverService(); + if (obsSvc) + obsSvc->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false); + return NS_OK; +} + +// Called by nsAppShell's native event callback +void +nsBaseAppShell::NativeEventCallback() +{ + if (!mNativeEventPending.exchange(false)) + return; + + // If DoProcessNextNativeEvent is on the stack, then we assume that we can + // just unwind and let nsThread::ProcessNextEvent process the next event. + // However, if we are called from a nested native event loop (maybe via some + // plug-in or library function), then go ahead and process Gecko events now. + if (mEventloopNestingState == eEventloopXPCOM) { + mEventloopNestingState = eEventloopOther; + // XXX there is a tiny risk we will never get a new NativeEventCallback, + // XXX see discussion in bug 389931. + return; + } + + // nsBaseAppShell::Run is not being used to pump events, so this may be + // our only opportunity to process pending gecko events. + + nsIThread *thread = NS_GetCurrentThread(); + bool prevBlockNativeEvent = mBlockNativeEvent; + if (mEventloopNestingState == eEventloopOther) { + if (!NS_HasPendingEvents(thread)) + return; + // We're in a nested native event loop and have some gecko events to + // process. While doing that we block processing native events from the + // appshell - instead, we want to get back to the nested native event + // loop ASAP (bug 420148). + mBlockNativeEvent = true; + } + + IncrementEventloopNestingLevel(); + EventloopNestingState prevVal = mEventloopNestingState; + NS_ProcessPendingEvents(thread, THREAD_EVENT_STARVATION_LIMIT); + mProcessedGeckoEvents = true; + mEventloopNestingState = prevVal; + mBlockNativeEvent = prevBlockNativeEvent; + + // Continue processing pending events later (we don't want to starve the + // embedders event loop). + if (NS_HasPendingEvents(thread)) + DoProcessMoreGeckoEvents(); + + DecrementEventloopNestingLevel(); +} + +// Note, this is currently overidden on windows, see comments in nsAppShell for +// details. +void +nsBaseAppShell::DoProcessMoreGeckoEvents() +{ + OnDispatchedEvent(nullptr); +} + + +// Main thread via OnProcessNextEvent below +bool +nsBaseAppShell::DoProcessNextNativeEvent(bool mayWait) +{ + // The next native event to be processed may trigger our NativeEventCallback, + // in which case we do not want it to process any thread events since we'll + // do that when this function returns. + // + // If the next native event is not our NativeEventCallback, then we may end + // up recursing into this function. + // + // However, if the next native event is not our NativeEventCallback, but it + // results in another native event loop, then our NativeEventCallback could + // fire and it will see mEventloopNestingState as eEventloopOther. + // + EventloopNestingState prevVal = mEventloopNestingState; + mEventloopNestingState = eEventloopXPCOM; + + IncrementEventloopNestingLevel(); + bool result = ProcessNextNativeEvent(mayWait); + DecrementEventloopNestingLevel(); + + mEventloopNestingState = prevVal; + return result; +} + +//------------------------------------------------------------------------- +// nsIAppShell methods: + +NS_IMETHODIMP +nsBaseAppShell::Run(void) +{ + NS_ENSURE_STATE(!mRunning); // should not call Run twice + mRunning = true; + + nsIThread *thread = NS_GetCurrentThread(); + + MessageLoop::current()->Run(); + + NS_ProcessPendingEvents(thread); + + mRunning = false; + return NS_OK; +} + +NS_IMETHODIMP +nsBaseAppShell::Exit(void) +{ + if (mRunning && !mExiting) { + MessageLoop::current()->Quit(); + } + mExiting = true; + return NS_OK; +} + +NS_IMETHODIMP +nsBaseAppShell::FavorPerformanceHint(bool favorPerfOverStarvation, + uint32_t starvationDelay) +{ + mStarvationDelay = PR_MillisecondsToInterval(starvationDelay); + if (favorPerfOverStarvation) { + ++mFavorPerf; + } else { + --mFavorPerf; + mSwitchTime = PR_IntervalNow(); + } + return NS_OK; +} + +NS_IMETHODIMP +nsBaseAppShell::SuspendNative() +{ + ++mSuspendNativeCount; + return NS_OK; +} + +NS_IMETHODIMP +nsBaseAppShell::ResumeNative() +{ + --mSuspendNativeCount; + NS_ASSERTION(mSuspendNativeCount >= 0, "Unbalanced call to nsBaseAppShell::ResumeNative!"); + return NS_OK; +} + +NS_IMETHODIMP +nsBaseAppShell::GetEventloopNestingLevel(uint32_t* aNestingLevelResult) +{ + NS_ENSURE_ARG_POINTER(aNestingLevelResult); + + *aNestingLevelResult = mEventloopNestingLevel; + + return NS_OK; +} + +//------------------------------------------------------------------------- +// nsIThreadObserver methods: + +// Called from any thread +NS_IMETHODIMP +nsBaseAppShell::OnDispatchedEvent(nsIThreadInternal *thr) +{ + if (mBlockNativeEvent) + return NS_OK; + + if (mNativeEventPending.exchange(true)) + return NS_OK; + + // Returns on the main thread in NativeEventCallback above + ScheduleNativeEventCallback(); + return NS_OK; +} + +// Called from the main thread +NS_IMETHODIMP +nsBaseAppShell::OnProcessNextEvent(nsIThreadInternal *thr, bool mayWait) +{ + if (mBlockNativeEvent) { + if (!mayWait) + return NS_OK; + // Hmm, we're in a nested native event loop and would like to get + // back to it ASAP, but it seems a gecko event has caused us to + // spin up a nested XPCOM event loop (eg. modal window), so we + // really must start processing native events here again. + mBlockNativeEvent = false; + if (NS_HasPendingEvents(thr)) + OnDispatchedEvent(thr); // in case we blocked it earlier + } + + PRIntervalTime start = PR_IntervalNow(); + PRIntervalTime limit = THREAD_EVENT_STARVATION_LIMIT; + + // Unblock outer nested wait loop (below). + if (mBlockedWait) + *mBlockedWait = false; + + bool *oldBlockedWait = mBlockedWait; + mBlockedWait = &mayWait; + + // When mayWait is true, we need to make sure that there is an event in the + // thread's event queue before we return. Otherwise, the thread will block + // on its event queue waiting for an event. + bool needEvent = mayWait; + // Reset prior to invoking DoProcessNextNativeEvent which might cause + // NativeEventCallback to process gecko events. + mProcessedGeckoEvents = false; + + if (mFavorPerf <= 0 && start > mSwitchTime + mStarvationDelay) { + // Favor pending native events + PRIntervalTime now = start; + bool keepGoing; + do { + mLastNativeEventTime = now; + keepGoing = DoProcessNextNativeEvent(false); + } while (keepGoing && ((now = PR_IntervalNow()) - start) < limit); + } else { + // Avoid starving native events completely when in performance mode + if (start - mLastNativeEventTime > limit) { + mLastNativeEventTime = start; + DoProcessNextNativeEvent(false); + } + } + + while (!NS_HasPendingEvents(thr) && !mProcessedGeckoEvents) { + // If we have been asked to exit from Run, then we should not wait for + // events to process. Note that an inner nested event loop causes + // 'mayWait' to become false too, through 'mBlockedWait'. + if (mExiting) + mayWait = false; + + mLastNativeEventTime = PR_IntervalNow(); + if (!DoProcessNextNativeEvent(mayWait) || !mayWait) + break; + } + + mBlockedWait = oldBlockedWait; + + // Make sure that the thread event queue does not block on its monitor, as + // it normally would do if it did not have any pending events. To avoid + // that, we simply insert a dummy event into its queue during shutdown. + if (needEvent && !mExiting && !NS_HasPendingEvents(thr)) { + DispatchDummyEvent(thr); + } + + return NS_OK; +} + +bool +nsBaseAppShell::DispatchDummyEvent(nsIThread* aTarget) +{ + NS_ASSERTION(NS_IsMainThread(), "Wrong thread!"); + + if (!mDummyEvent) + mDummyEvent = new mozilla::Runnable(); + + return NS_SUCCEEDED(aTarget->Dispatch(mDummyEvent, NS_DISPATCH_NORMAL)); +} + +void +nsBaseAppShell::IncrementEventloopNestingLevel() +{ + ++mEventloopNestingLevel; +#if defined(MOZ_CRASHREPORTER) + CrashReporter::SetEventloopNestingLevel(mEventloopNestingLevel); +#endif +} + +void +nsBaseAppShell::DecrementEventloopNestingLevel() +{ + --mEventloopNestingLevel; +#if defined(MOZ_CRASHREPORTER) + CrashReporter::SetEventloopNestingLevel(mEventloopNestingLevel); +#endif +} + +// Called from the main thread +NS_IMETHODIMP +nsBaseAppShell::AfterProcessNextEvent(nsIThreadInternal *thr, + bool eventWasProcessed) +{ + return NS_OK; +} + +NS_IMETHODIMP +nsBaseAppShell::Observe(nsISupports *subject, const char *topic, + const char16_t *data) +{ + NS_ASSERTION(!strcmp(topic, NS_XPCOM_SHUTDOWN_OBSERVER_ID), "oops"); + Exit(); + return NS_OK; +} -- cgit v1.2.3