gecko-dev/widget/nsBaseAppShell.cpp
Robert O'Callahan d5d49432af Bug 1184842. Allow BeforeSetAttr to preparse aValue. r=peterv
We will pass the preparsed value into AttributeWillChange.

--HG--
extra : commitid : HCiY4DRKWkC
extra : rebase_source : aa17a819a20578322380d388299279e4e41a690b
2015-08-01 17:14:06 +12:00

461 lines
14 KiB
C++

/* -*- 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)
, mRunningSyncSections(false)
, mRunning(false)
, mExiting(false)
, mBlockNativeEvent(false)
{
}
nsBaseAppShell::~nsBaseAppShell()
{
NS_ASSERTION(mSyncSections.IsEmpty(), "Must have run all sync sections");
}
nsresult
nsBaseAppShell::Init()
{
// Configure ourselves as an observer for the current thread:
nsCOMPtr<nsIThreadInternal> threadInt =
do_QueryInterface(NS_GetCurrentThread());
NS_ENSURE_STATE(threadInt);
threadInt->SetObserver(this);
nsCOMPtr<nsIObserverService> 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, uint32_t recursionDepth)
{
// 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);
// Make sure that any sync sections registered during this most recent event
// are run now. This is not considered a stable state because we're not back
// to the event loop yet.
RunSyncSections(false, recursionDepth);
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,
uint32_t recursionDepth)
{
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, recursionDepth);
} 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, recursionDepth);
}
}
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, recursionDepth) || !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);
}
// We're about to run an event, so we're in a stable state.
RunSyncSections(true, recursionDepth);
return NS_OK;
}
bool
nsBaseAppShell::DispatchDummyEvent(nsIThread* aTarget)
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
if (!mDummyEvent)
mDummyEvent = new nsRunnable();
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
}
void
nsBaseAppShell::RunSyncSectionsInternal(bool aStable,
uint32_t aThreadRecursionLevel)
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
NS_ASSERTION(!mSyncSections.IsEmpty(), "Nothing to do!");
// We don't support re-entering sync sections. This effectively means that
// sync sections may not spin the event loop.
MOZ_RELEASE_ASSERT(!mRunningSyncSections);
mRunningSyncSections = true;
// We've got synchronous sections. Run all of them that are are awaiting a
// stable state if aStable is true (i.e. we really are in a stable state).
// Also run the synchronous sections that are simply waiting for the right
// combination of event loop nesting level and thread recursion level.
// Note that a synchronous section could add another synchronous section, so
// we don't remove elements from mSyncSections until all sections have been
// run, or else we'll screw up our iteration. Any sync sections that are not
// ready to be run are saved for later.
nsTArray<SyncSection> pendingSyncSections;
for (uint32_t i = 0; i < mSyncSections.Length(); i++) {
SyncSection& section = mSyncSections[i];
if ((aStable && section.mStable) ||
(!section.mStable &&
section.mEventloopNestingLevel == mEventloopNestingLevel &&
section.mThreadRecursionLevel == aThreadRecursionLevel)) {
section.mRunnable->Run();
}
else {
// Add to pending list.
SyncSection* pending = pendingSyncSections.AppendElement();
section.Forget(pending);
}
}
mSyncSections.SwapElements(pendingSyncSections);
mRunningSyncSections = false;
}
void
nsBaseAppShell::ScheduleSyncSection(already_AddRefed<nsIRunnable> aRunnable,
bool aStable)
{
NS_ASSERTION(NS_IsMainThread(), "Should be on main thread.");
nsIThread* thread = NS_GetCurrentThread();
// Add this runnable to our list of synchronous sections.
SyncSection* section = mSyncSections.AppendElement();
section->mStable = aStable;
section->mRunnable = aRunnable;
// If aStable is false then this synchronous section is supposed to run before
// the next event at the current nesting level. Record the event loop nesting
// level and the thread recursion level so that the synchronous section will
// run at the proper time.
if (!aStable) {
section->mEventloopNestingLevel = mEventloopNestingLevel;
nsCOMPtr<nsIThreadInternal> threadInternal = do_QueryInterface(thread);
NS_ASSERTION(threadInternal, "This should never fail!");
uint32_t recursionLevel;
if (NS_FAILED(threadInternal->GetRecursionDepth(&recursionLevel))) {
NS_ERROR("This should never fail!");
}
// Due to the weird way that the thread recursion counter is implemented we
// subtract one from the recursion level if we have one.
section->mThreadRecursionLevel = recursionLevel ? recursionLevel - 1 : 0;
}
// Ensure we've got a pending event, else the callbacks will never run.
if (!NS_HasPendingEvents(thread) && !DispatchDummyEvent(thread)) {
RunSyncSections(true, 0);
}
}
// Called from the main thread
NS_IMETHODIMP
nsBaseAppShell::AfterProcessNextEvent(nsIThreadInternal *thr,
uint32_t recursionDepth,
bool eventWasProcessed)
{
// We've just finished running an event, so we're in a stable state.
RunSyncSections(true, recursionDepth);
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;
}
void
nsBaseAppShell::RunInStableState(already_AddRefed<nsIRunnable> aRunnable)
{
ScheduleSyncSection(mozilla::Move(aRunnable), true);
}
NS_IMETHODIMP
nsBaseAppShell::RunBeforeNextEvent(nsIRunnable* aRunnable)
{
nsCOMPtr<nsIRunnable> runnable = aRunnable;
ScheduleSyncSection(runnable.forget(), false);
return NS_OK;
}