diff options
Diffstat (limited to 'dom/events/EventStateManager.cpp')
| -rw-r--r-- | dom/events/EventStateManager.cpp | 6934 |
1 files changed, 6934 insertions, 0 deletions
diff --git a/dom/events/EventStateManager.cpp b/dom/events/EventStateManager.cpp new file mode 100644 index 0000000000..0ae756211b --- /dev/null +++ b/dom/events/EventStateManager.cpp @@ -0,0 +1,6934 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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 "EventStateManager.h" + +#include "mozilla/AsyncEventDispatcher.h" +#include "mozilla/Attributes.h" +#include "mozilla/EditorBase.h" +#include "mozilla/EventDispatcher.h" +#include "mozilla/EventForwards.h" +#include "mozilla/Hal.h" +#include "mozilla/HTMLEditor.h" +#include "mozilla/IMEStateManager.h" +#include "mozilla/Likely.h" +#include "mozilla/MiscEvents.h" +#include "mozilla/MathAlgorithms.h" +#include "mozilla/MouseEvents.h" +#include "mozilla/PointerLockManager.h" +#include "mozilla/PresShell.h" +#include "mozilla/ScopeExit.h" +#include "mozilla/ScrollTypes.h" +#include "mozilla/TextComposition.h" +#include "mozilla/TextControlElement.h" +#include "mozilla/TextEditor.h" +#include "mozilla/TextEvents.h" +#include "mozilla/TouchEvents.h" +#include "mozilla/Telemetry.h" +#include "mozilla/UniquePtr.h" +#include "mozilla/dom/BrowserBridgeChild.h" +#include "mozilla/dom/BrowsingContext.h" +#include "mozilla/dom/CanonicalBrowsingContext.h" +#include "mozilla/dom/ContentChild.h" +#include "mozilla/dom/DOMIntersectionObserver.h" +#include "mozilla/dom/DragEvent.h" +#include "mozilla/dom/Event.h" +#include "mozilla/dom/FrameLoaderBinding.h" +#include "mozilla/dom/HTMLLabelElement.h" +#include "mozilla/dom/HTMLInputElement.h" +#include "mozilla/dom/MouseEventBinding.h" +#include "mozilla/dom/BrowserChild.h" +#include "mozilla/dom/PointerEventHandler.h" +#include "mozilla/dom/UIEvent.h" +#include "mozilla/dom/UIEventBinding.h" +#include "mozilla/dom/UserActivation.h" +#include "mozilla/dom/WheelEventBinding.h" +#include "mozilla/glean/GleanMetrics.h" +#include "mozilla/StaticPrefs_accessibility.h" +#include "mozilla/StaticPrefs_browser.h" +#include "mozilla/StaticPrefs_dom.h" +#include "mozilla/StaticPrefs_layout.h" +#include "mozilla/StaticPrefs_mousewheel.h" +#include "mozilla/StaticPrefs_ui.h" +#include "mozilla/StaticPrefs_zoom.h" + +#include "ContentEventHandler.h" +#include "IMEContentObserver.h" +#include "WheelHandlingHelper.h" +#include "RemoteDragStartData.h" + +#include "nsCommandParams.h" +#include "nsCOMPtr.h" +#include "nsCopySupport.h" +#include "nsFocusManager.h" +#include "nsGenericHTMLElement.h" +#include "nsIClipboard.h" +#include "nsIContent.h" +#include "nsIContentInlines.h" +#include "mozilla/dom/Document.h" +#include "nsICookieJarSettings.h" +#include "nsIFrame.h" +#include "nsFrameLoaderOwner.h" +#include "nsIWidget.h" +#include "nsLiteralString.h" +#include "nsPresContext.h" +#include "nsTArray.h" +#include "nsGkAtoms.h" +#include "nsIFormControl.h" +#include "nsComboboxControlFrame.h" +#include "nsIScrollableFrame.h" +#include "nsIDOMXULControlElement.h" +#include "nsNameSpaceManager.h" +#include "nsIBaseWindow.h" +#include "nsFrameSelection.h" +#include "nsPIDOMWindow.h" +#include "nsPIWindowRoot.h" +#include "nsIWebNavigation.h" +#include "nsIDocumentViewer.h" +#include "nsFrameManager.h" +#include "nsIBrowserChild.h" +#include "nsMenuPopupFrame.h" + +#include "nsIObserverService.h" +#include "nsIDocShell.h" + +#include "nsSubDocumentFrame.h" +#include "nsLayoutUtils.h" +#include "nsIInterfaceRequestorUtils.h" +#include "nsUnicharUtils.h" +#include "nsContentUtils.h" + +#include "imgIContainer.h" +#include "nsIProperties.h" +#include "nsISupportsPrimitives.h" + +#include "nsServiceManagerUtils.h" +#include "nsITimer.h" +#include "nsFontMetrics.h" +#include "nsIDragService.h" +#include "nsIDragSession.h" +#include "mozilla/dom/DataTransfer.h" +#include "nsContentAreaDragDrop.h" +#include "nsTreeBodyFrame.h" +#include "nsIController.h" +#include "mozilla/Services.h" +#include "mozilla/dom/ContentParent.h" +#include "mozilla/dom/Record.h" +#include "mozilla/dom/Selection.h" + +#include "mozilla/Preferences.h" +#include "mozilla/LookAndFeel.h" +#include "mozilla/ProfilerLabels.h" +#include "Units.h" + +#ifdef XP_MACOSX +# import <ApplicationServices/ApplicationServices.h> +#endif + +namespace mozilla { + +using namespace dom; + +static const LayoutDeviceIntPoint kInvalidRefPoint = + LayoutDeviceIntPoint(-1, -1); + +static uint32_t gMouseOrKeyboardEventCounter = 0; +static nsITimer* gUserInteractionTimer = nullptr; +static nsITimerCallback* gUserInteractionTimerCallback = nullptr; + +static const double kCursorLoadingTimeout = 1000; // ms +static AutoWeakFrame gLastCursorSourceFrame; +static TimeStamp gLastCursorUpdateTime; +static TimeStamp gTypingStartTime; +static TimeStamp gTypingEndTime; +static int32_t gTypingInteractionKeyPresses = 0; +static dom::InteractionData gTypingInteraction = {}; + +static inline int32_t RoundDown(double aDouble) { + return (aDouble > 0) ? static_cast<int32_t>(floor(aDouble)) + : static_cast<int32_t>(ceil(aDouble)); +} + +static bool IsSelectingLink(nsIFrame* aTargetFrame) { + if (!aTargetFrame) { + return false; + } + const nsFrameSelection* frameSel = aTargetFrame->GetConstFrameSelection(); + if (!frameSel || !frameSel->GetDragState()) { + return false; + } + + if (!nsContentUtils::GetClosestLinkInFlatTree(aTargetFrame->GetContent())) { + return false; + } + return true; +} + +static UniquePtr<WidgetMouseEvent> CreateMouseOrPointerWidgetEvent( + WidgetMouseEvent* aMouseEvent, EventMessage aMessage, + EventTarget* aRelatedTarget); + +/** + * Returns the common ancestor for mouseup purpose, given the + * current mouseup target and the previous mousedown target. + */ +static nsINode* GetCommonAncestorForMouseUp( + nsINode* aCurrentMouseUpTarget, nsINode* aLastMouseDownTarget, + Maybe<FormControlType>& aLastMouseDownInputControlType) { + if (!aCurrentMouseUpTarget || !aLastMouseDownTarget) { + return nullptr; + } + + if (aCurrentMouseUpTarget == aLastMouseDownTarget) { + return aCurrentMouseUpTarget; + } + + // Build the chain of parents + AutoTArray<nsINode*, 30> parents1; + do { + parents1.AppendElement(aCurrentMouseUpTarget); + aCurrentMouseUpTarget = aCurrentMouseUpTarget->GetFlattenedTreeParentNode(); + } while (aCurrentMouseUpTarget); + + AutoTArray<nsINode*, 30> parents2; + do { + parents2.AppendElement(aLastMouseDownTarget); + if (aLastMouseDownTarget == parents1.LastElement()) { + break; + } + aLastMouseDownTarget = aLastMouseDownTarget->GetFlattenedTreeParentNode(); + } while (aLastMouseDownTarget); + + // Find where the parent chain differs + uint32_t pos1 = parents1.Length(); + uint32_t pos2 = parents2.Length(); + nsINode* parent = nullptr; + for (uint32_t len = std::min(pos1, pos2); len > 0; --len) { + nsINode* child1 = parents1.ElementAt(--pos1); + nsINode* child2 = parents2.ElementAt(--pos2); + if (child1 != child2) { + break; + } + + // If the input control type is different between mouseup and mousedown, + // this is not a valid click. + if (HTMLInputElement* input = HTMLInputElement::FromNodeOrNull(child1)) { + if (aLastMouseDownInputControlType.isSome() && + aLastMouseDownInputControlType.ref() != input->ControlType()) { + break; + } + } + parent = child1; + } + + return parent; +} + +/******************************************************************/ +/* mozilla::UITimerCallback */ +/******************************************************************/ + +class UITimerCallback final : public nsITimerCallback, public nsINamed { + public: + UITimerCallback() : mPreviousCount(0) {} + NS_DECL_ISUPPORTS + NS_DECL_NSITIMERCALLBACK + NS_DECL_NSINAMED + private: + ~UITimerCallback() = default; + uint32_t mPreviousCount; +}; + +NS_IMPL_ISUPPORTS(UITimerCallback, nsITimerCallback, nsINamed) + +// If aTimer is nullptr, this method always sends "user-interaction-inactive" +// notification. +NS_IMETHODIMP +UITimerCallback::Notify(nsITimer* aTimer) { + nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService(); + if (!obs) return NS_ERROR_FAILURE; + if ((gMouseOrKeyboardEventCounter == mPreviousCount) || !aTimer) { + gMouseOrKeyboardEventCounter = 0; + obs->NotifyObservers(nullptr, "user-interaction-inactive", nullptr); + if (gUserInteractionTimer) { + gUserInteractionTimer->Cancel(); + NS_RELEASE(gUserInteractionTimer); + } + } else { + obs->NotifyObservers(nullptr, "user-interaction-active", nullptr); + EventStateManager::UpdateUserActivityTimer(); + + if (XRE_IsParentProcess()) { + hal::BatteryInformation batteryInfo; + hal::GetCurrentBatteryInformation(&batteryInfo); + glean::power_battery::percentage_when_user_active.AccumulateSamples( + {uint64_t(batteryInfo.level() * 100)}); + } + } + mPreviousCount = gMouseOrKeyboardEventCounter; + return NS_OK; +} + +NS_IMETHODIMP +UITimerCallback::GetName(nsACString& aName) { + aName.AssignLiteral("UITimerCallback_timer"); + return NS_OK; +} + +/******************************************************************/ +/* mozilla::OverOutElementsWrapper */ +/******************************************************************/ + +OverOutElementsWrapper::OverOutElementsWrapper() : mLastOverFrame(nullptr) {} + +OverOutElementsWrapper::~OverOutElementsWrapper() = default; + +NS_IMPL_CYCLE_COLLECTION(OverOutElementsWrapper, mDeepestEnterEventTarget, + mDispatchingOverEventTarget, + mDispatchingOutOrDeepestLeaveEventTarget) +NS_IMPL_CYCLE_COLLECTING_ADDREF(OverOutElementsWrapper) +NS_IMPL_CYCLE_COLLECTING_RELEASE(OverOutElementsWrapper) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(OverOutElementsWrapper) + NS_INTERFACE_MAP_ENTRY(nsISupports) +NS_INTERFACE_MAP_END + +/******************************************************************/ +/* mozilla::EventStateManager */ +/******************************************************************/ + +static uint32_t sESMInstanceCount = 0; + +bool EventStateManager::sNormalLMouseEventInProcess = false; +int16_t EventStateManager::sCurrentMouseBtn = MouseButton::eNotPressed; +EventStateManager* EventStateManager::sActiveESM = nullptr; +EventStateManager* EventStateManager::sCursorSettingManager = nullptr; +AutoWeakFrame EventStateManager::sLastDragOverFrame = nullptr; +LayoutDeviceIntPoint EventStateManager::sPreLockScreenPoint = + LayoutDeviceIntPoint(0, 0); +LayoutDeviceIntPoint EventStateManager::sLastRefPoint = kInvalidRefPoint; +CSSIntPoint EventStateManager::sLastScreenPoint = CSSIntPoint(0, 0); +LayoutDeviceIntPoint EventStateManager::sSynthCenteringPoint = kInvalidRefPoint; +CSSIntPoint EventStateManager::sLastClientPoint = CSSIntPoint(0, 0); +nsCOMPtr<nsIContent> EventStateManager::sDragOverContent = nullptr; + +EventStateManager::WheelPrefs* EventStateManager::WheelPrefs::sInstance = + nullptr; +EventStateManager::DeltaAccumulator* + EventStateManager::DeltaAccumulator::sInstance = nullptr; + +constexpr const StyleCursorKind kInvalidCursorKind = + static_cast<StyleCursorKind>(255); + +EventStateManager::EventStateManager() + : mLockCursor(kInvalidCursorKind), + mCurrentTarget(nullptr), + // init d&d gesture state machine variables + mGestureDownPoint(0, 0), + mGestureModifiers(0), + mGestureDownButtons(0), + mPresContext(nullptr), + mShouldAlwaysUseLineDeltas(false), + mShouldAlwaysUseLineDeltasInitialized(false), + mGestureDownInTextControl(false), + mInTouchDrag(false), + m_haveShutdown(false) { + if (sESMInstanceCount == 0) { + gUserInteractionTimerCallback = new UITimerCallback(); + if (gUserInteractionTimerCallback) NS_ADDREF(gUserInteractionTimerCallback); + UpdateUserActivityTimer(); + } + ++sESMInstanceCount; +} + +nsresult EventStateManager::UpdateUserActivityTimer() { + if (!gUserInteractionTimerCallback) return NS_OK; + + if (!gUserInteractionTimer) { + gUserInteractionTimer = NS_NewTimer().take(); + } + + if (gUserInteractionTimer) { + gUserInteractionTimer->InitWithCallback( + gUserInteractionTimerCallback, + StaticPrefs::dom_events_user_interaction_interval(), + nsITimer::TYPE_ONE_SHOT); + } + return NS_OK; +} + +nsresult EventStateManager::Init() { + nsCOMPtr<nsIObserverService> observerService = + mozilla::services::GetObserverService(); + if (!observerService) return NS_ERROR_FAILURE; + + observerService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, true); + + return NS_OK; +} + +bool EventStateManager::ShouldAlwaysUseLineDeltas() { + if (MOZ_UNLIKELY(!mShouldAlwaysUseLineDeltasInitialized)) { + mShouldAlwaysUseLineDeltasInitialized = true; + mShouldAlwaysUseLineDeltas = + !StaticPrefs::dom_event_wheel_deltaMode_lines_disabled(); + if (!mShouldAlwaysUseLineDeltas && mDocument) { + if (nsIPrincipal* principal = + mDocument->GetPrincipalForPrefBasedHacks()) { + mShouldAlwaysUseLineDeltas = principal->IsURIInPrefList( + "dom.event.wheel-deltaMode-lines.always-enabled"); + } + } + } + return mShouldAlwaysUseLineDeltas; +} + +EventStateManager::~EventStateManager() { + ReleaseCurrentIMEContentObserver(); + + if (sActiveESM == this) { + sActiveESM = nullptr; + } + + if (StaticPrefs::ui_click_hold_context_menus()) { + KillClickHoldTimer(); + } + + if (sCursorSettingManager == this) { + sCursorSettingManager = nullptr; + } + + --sESMInstanceCount; + if (sESMInstanceCount == 0) { + WheelTransaction::Shutdown(); + if (gUserInteractionTimerCallback) { + gUserInteractionTimerCallback->Notify(nullptr); + NS_RELEASE(gUserInteractionTimerCallback); + } + if (gUserInteractionTimer) { + gUserInteractionTimer->Cancel(); + NS_RELEASE(gUserInteractionTimer); + } + WheelPrefs::Shutdown(); + DeltaAccumulator::Shutdown(); + } + + if (sDragOverContent && sDragOverContent->OwnerDoc() == mDocument) { + sDragOverContent = nullptr; + } + + if (!m_haveShutdown) { + Shutdown(); + + // Don't remove from Observer service in Shutdown because Shutdown also + // gets called from xpcom shutdown observer. And we don't want to remove + // from the service in that case. + + nsCOMPtr<nsIObserverService> observerService = + mozilla::services::GetObserverService(); + if (observerService) { + observerService->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID); + } + } +} + +nsresult EventStateManager::Shutdown() { + m_haveShutdown = true; + return NS_OK; +} + +NS_IMETHODIMP +EventStateManager::Observe(nsISupports* aSubject, const char* aTopic, + const char16_t* someData) { + if (!nsCRT::strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) { + Shutdown(); + } + + return NS_OK; +} + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(EventStateManager) + NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIObserver) + NS_INTERFACE_MAP_ENTRY(nsIObserver) + NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference) +NS_INTERFACE_MAP_END + +NS_IMPL_CYCLE_COLLECTING_ADDREF(EventStateManager) +NS_IMPL_CYCLE_COLLECTING_RELEASE(EventStateManager) + +NS_IMPL_CYCLE_COLLECTION_WEAK(EventStateManager, mCurrentTargetContent, + mGestureDownContent, mGestureDownFrameOwner, + mLastLeftMouseDownInfo.mLastMouseDownContent, + mLastMiddleMouseDownInfo.mLastMouseDownContent, + mLastRightMouseDownInfo.mLastMouseDownContent, + mActiveContent, mHoverContent, mURLTargetContent, + mPopoverPointerDownTarget, mMouseEnterLeaveHelper, + mPointersEnterLeaveHelper, mDocument, + mIMEContentObserver, mAccessKeys) + +void EventStateManager::ReleaseCurrentIMEContentObserver() { + if (mIMEContentObserver) { + mIMEContentObserver->DisconnectFromEventStateManager(); + } + mIMEContentObserver = nullptr; +} + +void EventStateManager::OnStartToObserveContent( + IMEContentObserver* aIMEContentObserver) { + if (mIMEContentObserver == aIMEContentObserver) { + return; + } + ReleaseCurrentIMEContentObserver(); + mIMEContentObserver = aIMEContentObserver; +} + +void EventStateManager::OnStopObservingContent( + IMEContentObserver* aIMEContentObserver) { + aIMEContentObserver->DisconnectFromEventStateManager(); + NS_ENSURE_TRUE_VOID(mIMEContentObserver == aIMEContentObserver); + mIMEContentObserver = nullptr; +} + +void EventStateManager::TryToFlushPendingNotificationsToIME() { + if (mIMEContentObserver) { + mIMEContentObserver->TryToFlushPendingNotifications(true); + } +} + +static bool IsMessageMouseUserActivity(EventMessage aMessage) { + return aMessage == eMouseMove || aMessage == eMouseUp || + aMessage == eMouseDown || aMessage == eMouseAuxClick || + aMessage == eMouseDoubleClick || aMessage == eMouseClick || + aMessage == eMouseActivate || aMessage == eMouseLongTap; +} + +static bool IsMessageGamepadUserActivity(EventMessage aMessage) { + return aMessage == eGamepadButtonDown || aMessage == eGamepadButtonUp || + aMessage == eGamepadAxisMove; +} + +// static +bool EventStateManager::IsKeyboardEventUserActivity(WidgetEvent* aEvent) { + // We ignore things that shouldn't cause popups, but also things that look + // like shortcut presses. In some obscure cases these may actually be + // website input, but any meaningful website will have other input anyway, + // and we can't very well tell whether shortcut input was supposed to be + // directed at chrome or the document. + + WidgetKeyboardEvent* keyEvent = aEvent->AsKeyboardEvent(); + // Access keys should be treated as page interaction. + if (keyEvent->ModifiersMatchWithAccessKey(AccessKeyType::eContent)) { + return true; + } + if (!keyEvent->CanTreatAsUserInput() || keyEvent->IsControl() || + keyEvent->IsMeta() || keyEvent->IsAlt()) { + return false; + } + // Deal with function keys: + switch (keyEvent->mKeyNameIndex) { + case KEY_NAME_INDEX_F1: + case KEY_NAME_INDEX_F2: + case KEY_NAME_INDEX_F3: + case KEY_NAME_INDEX_F4: + case KEY_NAME_INDEX_F5: + case KEY_NAME_INDEX_F6: + case KEY_NAME_INDEX_F7: + case KEY_NAME_INDEX_F8: + case KEY_NAME_INDEX_F9: + case KEY_NAME_INDEX_F10: + case KEY_NAME_INDEX_F11: + case KEY_NAME_INDEX_F12: + case KEY_NAME_INDEX_F13: + case KEY_NAME_INDEX_F14: + case KEY_NAME_INDEX_F15: + case KEY_NAME_INDEX_F16: + case KEY_NAME_INDEX_F17: + case KEY_NAME_INDEX_F18: + case KEY_NAME_INDEX_F19: + case KEY_NAME_INDEX_F20: + case KEY_NAME_INDEX_F21: + case KEY_NAME_INDEX_F22: + case KEY_NAME_INDEX_F23: + case KEY_NAME_INDEX_F24: + return false; + default: + return true; + } +} + +static void OnTypingInteractionEnded() { + // We don't consider a single keystroke to be typing. + if (gTypingInteractionKeyPresses > 1) { + gTypingInteraction.mInteractionCount += gTypingInteractionKeyPresses; + gTypingInteraction.mInteractionTimeInMilliseconds += static_cast<uint32_t>( + std::ceil((gTypingEndTime - gTypingStartTime).ToMilliseconds())); + } + + gTypingInteractionKeyPresses = 0; + gTypingStartTime = TimeStamp(); + gTypingEndTime = TimeStamp(); +} + +static void HandleKeyUpInteraction(WidgetKeyboardEvent* aKeyEvent) { + if (EventStateManager::IsKeyboardEventUserActivity(aKeyEvent)) { + TimeStamp now = TimeStamp::Now(); + if (gTypingEndTime.IsNull()) { + gTypingEndTime = now; + } + TimeDuration delay = now - gTypingEndTime; + // Has it been too long since the last keystroke to be considered typing? + if (gTypingInteractionKeyPresses > 0 && + delay > + TimeDuration::FromMilliseconds( + StaticPrefs::browser_places_interactions_typing_timeout_ms())) { + OnTypingInteractionEnded(); + } + gTypingInteractionKeyPresses++; + if (gTypingStartTime.IsNull()) { + gTypingStartTime = now; + } + gTypingEndTime = now; + } +} + +nsresult EventStateManager::PreHandleEvent(nsPresContext* aPresContext, + WidgetEvent* aEvent, + nsIFrame* aTargetFrame, + nsIContent* aTargetContent, + nsEventStatus* aStatus, + nsIContent* aOverrideClickTarget) { + NS_ENSURE_ARG_POINTER(aStatus); + NS_ENSURE_ARG(aPresContext); + if (!aEvent) { + NS_ERROR("aEvent is null. This should never happen."); + return NS_ERROR_NULL_POINTER; + } + + NS_WARNING_ASSERTION( + !aTargetFrame || !aTargetFrame->GetContent() || + aTargetFrame->GetContent() == aTargetContent || + aTargetFrame->GetContent()->GetFlattenedTreeParent() == + aTargetContent || + aTargetFrame->IsGeneratedContentFrame(), + "aTargetFrame should be related with aTargetContent"); +#if DEBUG + if (aTargetFrame && aTargetFrame->IsGeneratedContentFrame()) { + nsCOMPtr<nsIContent> targetContent; + aTargetFrame->GetContentForEvent(aEvent, getter_AddRefs(targetContent)); + MOZ_ASSERT(aTargetContent == targetContent, + "Unexpected target for generated content frame!"); + } +#endif + + mCurrentTarget = aTargetFrame; + mCurrentTargetContent = nullptr; + + // Do not take account eMouseEnterIntoWidget/ExitFromWidget so that loading + // a page when user is not active doesn't change the state to active. + WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent(); + if (aEvent->IsTrusted() && + ((mouseEvent && mouseEvent->IsReal() && + IsMessageMouseUserActivity(mouseEvent->mMessage)) || + aEvent->mClass == eWheelEventClass || + aEvent->mClass == ePointerEventClass || + aEvent->mClass == eTouchEventClass || + aEvent->mClass == eKeyboardEventClass || + (aEvent->mClass == eDragEventClass && aEvent->mMessage == eDrop) || + IsMessageGamepadUserActivity(aEvent->mMessage))) { + if (gMouseOrKeyboardEventCounter == 0) { + nsCOMPtr<nsIObserverService> obs = + mozilla::services::GetObserverService(); + if (obs) { + obs->NotifyObservers(nullptr, "user-interaction-active", nullptr); + UpdateUserActivityTimer(); + } + } + ++gMouseOrKeyboardEventCounter; + + nsCOMPtr<nsINode> node = aTargetContent; + if (node && + ((aEvent->mMessage == eKeyUp && IsKeyboardEventUserActivity(aEvent)) || + aEvent->mMessage == eMouseUp || aEvent->mMessage == eWheel || + aEvent->mMessage == eTouchEnd || aEvent->mMessage == ePointerUp || + aEvent->mMessage == eDrop)) { + Document* doc = node->OwnerDoc(); + while (doc) { + doc->SetUserHasInteracted(); + doc = nsContentUtils::IsChildOfSameType(doc) + ? doc->GetInProcessParentDocument() + : nullptr; + } + } + } + + WheelTransaction::OnEvent(aEvent); + + // Focus events don't necessarily need a frame. + if (!mCurrentTarget && !aTargetContent) { + NS_ERROR("mCurrentTarget and aTargetContent are null"); + return NS_ERROR_NULL_POINTER; + } +#ifdef DEBUG + if (aEvent->HasDragEventMessage() && PointerLockManager::IsLocked()) { + NS_ASSERTION(PointerLockManager::IsLocked(), + "Pointer is locked. Drag events should be suppressed when " + "the pointer is locked."); + } +#endif + // Store last known screenPoint and clientPoint so pointer lock + // can use these values as constants. + if (aEvent->IsTrusted() && + ((mouseEvent && mouseEvent->IsReal()) || + aEvent->mClass == eWheelEventClass) && + !PointerLockManager::IsLocked()) { + // XXX Probably doesn't matter much, but storing these in CSS pixels instead + // of device pixels means behavior can be a bit odd if you zoom while + // pointer-locked. + sLastScreenPoint = + Event::GetScreenCoords(aPresContext, aEvent, aEvent->mRefPoint) + .extract(); + sLastClientPoint = Event::GetClientCoords( + aPresContext, aEvent, aEvent->mRefPoint, CSSIntPoint(0, 0)); + } + + *aStatus = nsEventStatus_eIgnore; + + if (aEvent->mClass == eQueryContentEventClass) { + HandleQueryContentEvent(aEvent->AsQueryContentEvent()); + return NS_OK; + } + + WidgetTouchEvent* touchEvent = aEvent->AsTouchEvent(); + if (touchEvent && mInTouchDrag) { + if (touchEvent->mMessage == eTouchMove) { + GenerateDragGesture(aPresContext, touchEvent); + } else { + mInTouchDrag = false; + StopTrackingDragGesture(true); + } + } + + switch (aEvent->mMessage) { + case eContextMenu: + if (PointerLockManager::IsLocked()) { + return NS_ERROR_DOM_INVALID_STATE_ERR; + } + break; + case eMouseTouchDrag: + mInTouchDrag = true; + BeginTrackingDragGesture(aPresContext, mouseEvent, aTargetFrame); + break; + case eMouseDown: { + switch (mouseEvent->mButton) { + case MouseButton::ePrimary: + BeginTrackingDragGesture(aPresContext, mouseEvent, aTargetFrame); + mLastLeftMouseDownInfo.mClickCount = mouseEvent->mClickCount; + SetClickCount(mouseEvent, aStatus); + sNormalLMouseEventInProcess = true; + break; + case MouseButton::eMiddle: + mLastMiddleMouseDownInfo.mClickCount = mouseEvent->mClickCount; + SetClickCount(mouseEvent, aStatus); + break; + case MouseButton::eSecondary: + mLastRightMouseDownInfo.mClickCount = mouseEvent->mClickCount; + SetClickCount(mouseEvent, aStatus); + break; + } + NotifyTargetUserActivation(aEvent, aTargetContent); + break; + } + case eMouseUp: { + switch (mouseEvent->mButton) { + case MouseButton::ePrimary: + if (StaticPrefs::ui_click_hold_context_menus()) { + KillClickHoldTimer(); + } + mInTouchDrag = false; + StopTrackingDragGesture(true); + sNormalLMouseEventInProcess = false; + // then fall through... + [[fallthrough]]; + case MouseButton::eSecondary: + case MouseButton::eMiddle: + RefPtr<EventStateManager> esm = + ESMFromContentOrThis(aOverrideClickTarget); + esm->SetClickCount(mouseEvent, aStatus, aOverrideClickTarget); + break; + } + break; + } + case eMouseEnterIntoWidget: + PointerEventHandler::UpdateActivePointerState(mouseEvent, aTargetContent); + // In some cases on e10s eMouseEnterIntoWidget + // event was sent twice into child process of content. + // (From specific widget code (sending is not permanent) and + // from ESM::DispatchMouseOrPointerEvent (sending is permanent)). + // IsCrossProcessForwardingStopped() helps to suppress sending accidental + // event from widget code. + aEvent->StopCrossProcessForwarding(); + break; + case eMouseExitFromWidget: + // If this is a remote frame, we receive eMouseExitFromWidget from the + // parent the mouse exits our content. Since the parent may update the + // cursor while the mouse is outside our frame, and since PuppetWidget + // caches the current cursor internally, re-entering our content (say from + // over a window edge) wont update the cursor if the cached value and the + // current cursor match. So when the mouse exits a remote frame, clear the + // cached widget cursor so a proper update will occur when the mouse + // re-enters. + if (XRE_IsContentProcess()) { + ClearCachedWidgetCursor(mCurrentTarget); + } + + // IsCrossProcessForwardingStopped() helps to suppress double event + // sending into process of content. For more information see comment + // above, at eMouseEnterIntoWidget case. + aEvent->StopCrossProcessForwarding(); + + // If the event is not a top-level window or puppet widget exit, then it's + // not really an exit --- we may have traversed widget boundaries but + // we're still in our toplevel window or puppet widget. + if (mouseEvent->mExitFrom.value() != + WidgetMouseEvent::ePlatformTopLevel && + mouseEvent->mExitFrom.value() != WidgetMouseEvent::ePuppet) { + // Treat it as a synthetic move so we don't generate spurious + // "exit" or "move" events. Any necessary "out" or "over" events + // will be generated by GenerateMouseEnterExit + mouseEvent->mMessage = eMouseMove; + mouseEvent->mReason = WidgetMouseEvent::eSynthesized; + // then fall through... + } else { + MOZ_ASSERT_IF(XRE_IsParentProcess(), + mouseEvent->mExitFrom.value() == + WidgetMouseEvent::ePlatformTopLevel); + MOZ_ASSERT_IF(XRE_IsContentProcess(), mouseEvent->mExitFrom.value() == + WidgetMouseEvent::ePuppet); + // We should synthetize corresponding pointer events + GeneratePointerEnterExit(ePointerLeave, mouseEvent); + GenerateMouseEnterExit(mouseEvent); + // This is really an exit and should stop here + aEvent->mMessage = eVoidEvent; + break; + } + [[fallthrough]]; + case eMouseMove: + case ePointerDown: + if (aEvent->mMessage == ePointerDown) { + PointerEventHandler::UpdateActivePointerState(mouseEvent, + aTargetContent); + PointerEventHandler::ImplicitlyCapturePointer(aTargetFrame, aEvent); + if (mouseEvent->mInputSource != MouseEvent_Binding::MOZ_SOURCE_TOUCH) { + NotifyTargetUserActivation(aEvent, aTargetContent); + } + + LightDismissOpenPopovers(aEvent, aTargetContent); + } + [[fallthrough]]; + case ePointerMove: { + if (!mInTouchDrag && + PointerEventHandler::IsDragAndDropEnabled(*mouseEvent)) { + GenerateDragGesture(aPresContext, mouseEvent); + } + // on the Mac, GenerateDragGesture() may not return until the drag + // has completed and so |aTargetFrame| may have been deleted (moving + // a bookmark, for example). If this is the case, however, we know + // that ClearFrameRefs() has been called and it cleared out + // |mCurrentTarget|. As a result, we should pass |mCurrentTarget| + // into UpdateCursor(). + UpdateCursor(aPresContext, mouseEvent, mCurrentTarget, aStatus); + + UpdateLastRefPointOfMouseEvent(mouseEvent); + if (PointerLockManager::IsLocked()) { + ResetPointerToWindowCenterWhilePointerLocked(mouseEvent); + } + UpdateLastPointerPosition(mouseEvent); + + GenerateMouseEnterExit(mouseEvent); + // Flush pending layout changes, so that later mouse move events + // will go to the right nodes. + FlushLayout(aPresContext); + break; + } + case ePointerUp: + LightDismissOpenPopovers(aEvent, aTargetContent); + break; + case ePointerGotCapture: + GenerateMouseEnterExit(mouseEvent); + break; + case eDragStart: + if (StaticPrefs::ui_click_hold_context_menus()) { + // an external drag gesture event came in, not generated internally + // by Gecko. Make sure we get rid of the click-hold timer. + KillClickHoldTimer(); + } + break; + case eDragOver: { + WidgetDragEvent* dragEvent = aEvent->AsDragEvent(); + MOZ_ASSERT(dragEvent); + if (dragEvent->mFlags.mIsSynthesizedForTests) { + dragEvent->InitDropEffectForTests(); + } + // Send the enter/exit events before eDrop. + GenerateDragDropEnterExit(aPresContext, dragEvent); + break; + } + case eDrop: + if (aEvent->mFlags.mIsSynthesizedForTests) { + MOZ_ASSERT(aEvent->AsDragEvent()); + aEvent->AsDragEvent()->InitDropEffectForTests(); + } + break; + + case eKeyPress: { + WidgetKeyboardEvent* keyEvent = aEvent->AsKeyboardEvent(); + if (keyEvent->ModifiersMatchWithAccessKey(AccessKeyType::eChrome) || + keyEvent->ModifiersMatchWithAccessKey(AccessKeyType::eContent)) { + // If the eKeyPress event will be sent to a remote process, this + // process needs to wait reply from the remote process for checking if + // preceding eKeyDown event is consumed. If preceding eKeyDown event + // is consumed in the remote process, BrowserChild won't send the event + // back to this process. So, only when this process receives a reply + // eKeyPress event in BrowserParent, we should handle accesskey in this + // process. + if (IsTopLevelRemoteTarget(GetFocusedElement())) { + // However, if there is no accesskey target for the key combination, + // we don't need to wait reply from the remote process. Otherwise, + // Mark the event as waiting reply from remote process and stop + // propagation in this process. + if (CheckIfEventMatchesAccessKey(keyEvent, aPresContext)) { + keyEvent->StopPropagation(); + keyEvent->MarkAsWaitingReplyFromRemoteProcess(); + } + } + // If the event target is in this process, we can handle accesskey now + // since if preceding eKeyDown event was consumed, eKeyPress event + // won't be dispatched by widget. So, coming eKeyPress event means + // that the preceding eKeyDown event wasn't consumed in this case. + else { + AutoTArray<uint32_t, 10> accessCharCodes; + keyEvent->GetAccessKeyCandidates(accessCharCodes); + + if (HandleAccessKey(keyEvent, aPresContext, accessCharCodes)) { + *aStatus = nsEventStatus_eConsumeNoDefault; + } + } + } + } + // then fall through... + [[fallthrough]]; + case eKeyDown: + if (aEvent->mMessage == eKeyDown) { + NotifyTargetUserActivation(aEvent, aTargetContent); + } + [[fallthrough]]; + case eKeyUp: { + Element* element = GetFocusedElement(); + if (element) { + mCurrentTargetContent = element; + } + + // NOTE: Don't refer TextComposition::IsComposing() since UI Events + // defines that KeyboardEvent.isComposing is true when it's + // dispatched after compositionstart and compositionend. + // TextComposition::IsComposing() is false even before + // compositionend if there is no composing string. + // And also don't expose other document's composition state. + // A native IME context is typically shared by multiple documents. + // So, don't use GetTextCompositionFor(nsIWidget*) here. + RefPtr<TextComposition> composition = + IMEStateManager::GetTextCompositionFor(aPresContext); + aEvent->AsKeyboardEvent()->mIsComposing = !!composition; + + // Widget may need to perform default action for specific keyboard + // event if it's not consumed. In this case, widget has already marked + // the event as "waiting reply from remote process". However, we need + // to reset it if the target (focused content) isn't in a remote process + // because PresShell needs to check if it's marked as so before + // dispatching events into the DOM tree. + if (aEvent->IsWaitingReplyFromRemoteProcess() && + !aEvent->PropagationStopped() && !IsTopLevelRemoteTarget(element)) { + aEvent->ResetWaitingReplyFromRemoteProcessState(); + } + } break; + case eWheel: + case eWheelOperationStart: + case eWheelOperationEnd: { + NS_ASSERTION(aEvent->IsTrusted(), + "Untrusted wheel event shouldn't be here"); + using DeltaModeCheckingState = WidgetWheelEvent::DeltaModeCheckingState; + + if (Element* element = GetFocusedElement()) { + mCurrentTargetContent = element; + } + + if (aEvent->mMessage != eWheel) { + break; + } + + WidgetWheelEvent* wheelEvent = aEvent->AsWheelEvent(); + WheelPrefs::GetInstance()->ApplyUserPrefsToDelta(wheelEvent); + + // If we won't dispatch a DOM event for this event, nothing to do anymore. + if (!wheelEvent->IsAllowedToDispatchDOMEvent()) { + break; + } + + if (StaticPrefs::dom_event_wheel_deltaMode_lines_always_disabled()) { + wheelEvent->mDeltaModeCheckingState = DeltaModeCheckingState::Unchecked; + } else if (ShouldAlwaysUseLineDeltas()) { + wheelEvent->mDeltaModeCheckingState = DeltaModeCheckingState::Checked; + } else { + wheelEvent->mDeltaModeCheckingState = DeltaModeCheckingState::Unknown; + } + + // Init lineOrPageDelta values for line scroll events for some devices + // on some platforms which might dispatch wheel events which don't + // have lineOrPageDelta values. And also, if delta values are + // customized by prefs, this recomputes them. + DeltaAccumulator::GetInstance()->InitLineOrPageDelta(aTargetFrame, this, + wheelEvent); + } break; + case eSetSelection: { + RefPtr<Element> focuedElement = GetFocusedElement(); + IMEStateManager::HandleSelectionEvent(aPresContext, focuedElement, + aEvent->AsSelectionEvent()); + break; + } + case eContentCommandCut: + case eContentCommandCopy: + case eContentCommandPaste: + case eContentCommandDelete: + case eContentCommandUndo: + case eContentCommandRedo: + case eContentCommandPasteTransferable: + case eContentCommandLookUpDictionary: + DoContentCommandEvent(aEvent->AsContentCommandEvent()); + break; + case eContentCommandInsertText: + DoContentCommandInsertTextEvent(aEvent->AsContentCommandEvent()); + break; + case eContentCommandScroll: + DoContentCommandScrollEvent(aEvent->AsContentCommandEvent()); + break; + case eCompositionStart: + if (aEvent->IsTrusted()) { + // If the event is trusted event, set the selected text to data of + // composition event. + WidgetCompositionEvent* compositionEvent = aEvent->AsCompositionEvent(); + WidgetQueryContentEvent querySelectedTextEvent( + true, eQuerySelectedText, compositionEvent->mWidget); + HandleQueryContentEvent(&querySelectedTextEvent); + if (querySelectedTextEvent.FoundSelection()) { + compositionEvent->mData = querySelectedTextEvent.mReply->DataRef(); + } + NS_ASSERTION(querySelectedTextEvent.Succeeded(), + "Failed to get selected text"); + } + break; + case eTouchStart: + SetGestureDownPoint(aEvent->AsTouchEvent()); + break; + case eTouchEnd: + NotifyTargetUserActivation(aEvent, aTargetContent); + break; + default: + break; + } + return NS_OK; +} + +// Returns true if this event is likely an user activation for a link or +// a link-like button, where modifier keys are likely be used for controlling +// where the link is opened. +// +// The modifiers associated with the user activation is used for controlling +// where the `window.open` is opened into. +static bool CanReflectModifiersToUserActivation(WidgetInputEvent* aEvent) { + MOZ_ASSERT(aEvent->mMessage == eKeyDown || aEvent->mMessage == eMouseDown || + aEvent->mMessage == ePointerDown || aEvent->mMessage == eTouchEnd); + + WidgetKeyboardEvent* keyEvent = aEvent->AsKeyboardEvent(); + if (keyEvent) { + return keyEvent->CanReflectModifiersToUserActivation(); + } + + return true; +} + +void EventStateManager::NotifyTargetUserActivation(WidgetEvent* aEvent, + nsIContent* aTargetContent) { + if (!aEvent->IsTrusted()) { + return; + } + + WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent(); + if (mouseEvent && !mouseEvent->IsReal()) { + return; + } + + nsCOMPtr<nsINode> node = aTargetContent; + if (!node) { + return; + } + + Document* doc = node->OwnerDoc(); + if (!doc) { + return; + } + + // Don't gesture activate for key events for keys which are likely + // to be interaction with the browser, OS. + WidgetKeyboardEvent* keyEvent = aEvent->AsKeyboardEvent(); + if (keyEvent && !keyEvent->CanUserGestureActivateTarget()) { + return; + } + + // Touch gestures that end outside the drag target were touches that turned + // into scroll/pan/swipe actions. We don't want to gesture activate on such + // actions, we want to only gesture activate on touches that are taps. + // That is, touches that end in roughly the same place that they started. + if (aEvent->mMessage == eTouchEnd && aEvent->AsTouchEvent() && + IsEventOutsideDragThreshold(aEvent->AsTouchEvent())) { + return; + } + + // Do not treat the click on scrollbar as a user interaction with the web + // content. + if (StaticPrefs::dom_user_activation_ignore_scrollbars() && + (aEvent->mMessage == eMouseDown || aEvent->mMessage == ePointerDown) && + aTargetContent->IsInNativeAnonymousSubtree()) { + nsIContent* current = aTargetContent; + do { + nsIContent* root = current->GetClosestNativeAnonymousSubtreeRoot(); + if (!root) { + break; + } + if (root->IsXULElement(nsGkAtoms::scrollbar)) { + return; + } + current = root->GetParent(); + } while (current); + } + + MOZ_ASSERT(aEvent->mMessage == eKeyDown || aEvent->mMessage == eMouseDown || + aEvent->mMessage == ePointerDown || aEvent->mMessage == eTouchEnd); + UserActivation::Modifiers modifiers; + if (WidgetInputEvent* inputEvent = aEvent->AsInputEvent()) { + if (CanReflectModifiersToUserActivation(inputEvent)) { + if (inputEvent->IsShift()) { + modifiers.SetShift(); + } + if (inputEvent->IsMeta()) { + modifiers.SetMeta(); + } + if (inputEvent->IsControl()) { + modifiers.SetControl(); + } + if (inputEvent->IsAlt()) { + modifiers.SetAlt(); + } + } + } + doc->NotifyUserGestureActivation(modifiers); +} + +// https://html.spec.whatwg.org/multipage/popover.html#popover-light-dismiss +void EventStateManager::LightDismissOpenPopovers(WidgetEvent* aEvent, + nsIContent* aTargetContent) { + MOZ_ASSERT(aEvent->mMessage == ePointerDown || aEvent->mMessage == ePointerUp, + "Light dismiss must be called for pointer up/down only"); + + if (!StaticPrefs::dom_element_popover_enabled() || !aEvent->IsTrusted() || + !aTargetContent) { + return; + } + + Element* topmostPopover = aTargetContent->OwnerDoc()->GetTopmostAutoPopover(); + if (!topmostPopover) { + return; + } + + // Pointerdown: set document's popover pointerdown target to the result of + // running topmost clicked popover given target. + if (aEvent->mMessage == ePointerDown) { + mPopoverPointerDownTarget = aTargetContent->GetTopmostClickedPopover(); + return; + } + + // Pointerup: hide open popovers. + RefPtr<nsINode> ancestor = aTargetContent->GetTopmostClickedPopover(); + bool sameTarget = mPopoverPointerDownTarget == ancestor; + mPopoverPointerDownTarget = nullptr; + if (!sameTarget) { + return; + } + + if (!ancestor) { + ancestor = aTargetContent->OwnerDoc(); + } + RefPtr<Document> doc(ancestor->OwnerDoc()); + doc->HideAllPopoversUntil(*ancestor, false, true); +} + +already_AddRefed<EventStateManager> EventStateManager::ESMFromContentOrThis( + nsIContent* aContent) { + if (aContent) { + PresShell* presShell = aContent->OwnerDoc()->GetPresShell(); + if (presShell) { + nsPresContext* prescontext = presShell->GetPresContext(); + if (prescontext) { + RefPtr<EventStateManager> esm = prescontext->EventStateManager(); + if (esm) { + return esm.forget(); + } + } + } + } + + RefPtr<EventStateManager> esm = this; + return esm.forget(); +} + +EventStateManager::LastMouseDownInfo& EventStateManager::GetLastMouseDownInfo( + int16_t aButton) { + switch (aButton) { + case MouseButton::ePrimary: + return mLastLeftMouseDownInfo; + case MouseButton::eMiddle: + return mLastMiddleMouseDownInfo; + case MouseButton::eSecondary: + return mLastRightMouseDownInfo; + default: + MOZ_ASSERT_UNREACHABLE("This button shouldn't use this method"); + return mLastLeftMouseDownInfo; + } +} + +void EventStateManager::HandleQueryContentEvent( + WidgetQueryContentEvent* aEvent) { + switch (aEvent->mMessage) { + case eQuerySelectedText: + case eQueryTextContent: + case eQueryCaretRect: + case eQueryTextRect: + case eQueryEditorRect: + if (!IsTargetCrossProcess(aEvent)) { + break; + } + // Will not be handled locally, remote the event + GetCrossProcessTarget()->HandleQueryContentEvent(*aEvent); + return; + // Following events have not been supported in e10s mode yet. + case eQueryContentState: + case eQuerySelectionAsTransferable: + case eQueryCharacterAtPoint: + case eQueryDOMWidgetHittest: + case eQueryTextRectArray: + break; + default: + return; + } + + // If there is an IMEContentObserver, we need to handle QueryContentEvent + // with it. + if (mIMEContentObserver) { + RefPtr<IMEContentObserver> contentObserver = mIMEContentObserver; + contentObserver->HandleQueryContentEvent(aEvent); + return; + } + + ContentEventHandler handler(mPresContext); + handler.HandleQueryContentEvent(aEvent); +} + +static AccessKeyType GetAccessKeyTypeFor(nsISupports* aDocShell) { + nsCOMPtr<nsIDocShellTreeItem> treeItem(do_QueryInterface(aDocShell)); + if (!treeItem) { + return AccessKeyType::eNone; + } + + switch (treeItem->ItemType()) { + case nsIDocShellTreeItem::typeChrome: + return AccessKeyType::eChrome; + case nsIDocShellTreeItem::typeContent: + return AccessKeyType::eContent; + default: + return AccessKeyType::eNone; + } +} + +static bool IsAccessKeyTarget(Element* aElement, nsAString& aKey) { + // Use GetAttr because we want Unicode case=insensitive matching + // XXXbz shouldn't this be case-sensitive, per spec? + nsString contentKey; + if (!aElement || !aElement->GetAttr(nsGkAtoms::accesskey, contentKey) || + !contentKey.Equals(aKey, nsCaseInsensitiveStringComparator)) { + return false; + } + + if (!aElement->IsXULElement()) { + return true; + } + + // For XUL we do visibility checks. + nsIFrame* frame = aElement->GetPrimaryFrame(); + if (!frame) { + return false; + } + + if (frame->IsFocusable()) { + return true; + } + + if (!frame->IsVisibleConsideringAncestors()) { + return false; + } + + // XUL controls can be activated. + nsCOMPtr<nsIDOMXULControlElement> control = aElement->AsXULControl(); + if (control) { + return true; + } + + // XUL label elements are never focusable, so we need to check for them + // explicitly before giving up. + if (aElement->IsXULElement(nsGkAtoms::label)) { + return true; + } + + return false; +} + +bool EventStateManager::CheckIfEventMatchesAccessKey( + WidgetKeyboardEvent* aEvent, nsPresContext* aPresContext) { + AutoTArray<uint32_t, 10> accessCharCodes; + aEvent->GetAccessKeyCandidates(accessCharCodes); + return WalkESMTreeToHandleAccessKey(aEvent, aPresContext, accessCharCodes, + nullptr, eAccessKeyProcessingNormal, + false); +} + +bool EventStateManager::LookForAccessKeyAndExecute( + nsTArray<uint32_t>& aAccessCharCodes, bool aIsTrustedEvent, bool aIsRepeat, + bool aExecute) { + int32_t count, start = -1; + if (Element* focusedElement = GetFocusedElement()) { + start = mAccessKeys.IndexOf(focusedElement); + if (start == -1 && focusedElement->IsInNativeAnonymousSubtree()) { + start = mAccessKeys.IndexOf(Element::FromNodeOrNull( + focusedElement->GetClosestNativeAnonymousSubtreeRootParentOrHost())); + } + } + RefPtr<Element> element; + int32_t length = mAccessKeys.Count(); + for (uint32_t i = 0; i < aAccessCharCodes.Length(); ++i) { + uint32_t ch = aAccessCharCodes[i]; + nsAutoString accessKey; + AppendUCS4ToUTF16(ch, accessKey); + for (count = 1; count <= length; ++count) { + // mAccessKeys always stores Element instances. + MOZ_DIAGNOSTIC_ASSERT(length == mAccessKeys.Count()); + element = mAccessKeys[(start + count) % length]; + if (IsAccessKeyTarget(element, accessKey)) { + if (!aExecute) { + return true; + } + Document* doc = element->OwnerDoc(); + const bool shouldActivate = [&] { + if (!StaticPrefs::accessibility_accesskeycausesactivation()) { + return false; + } + if (aIsRepeat && nsContentUtils::IsChromeDoc(doc)) { + return false; + } + + // XXXedgar, Bug 1700646, maybe we could use other data structure to + // make searching target with same accesskey easier, and current setup + // could not ensure we cycle the target with tree order. + int32_t j = 0; + while (++j < length) { + Element* el = mAccessKeys[(start + count + j) % length]; + if (IsAccessKeyTarget(el, accessKey)) { + return false; + } + } + return true; + }(); + + // TODO(bug 1641171): This shouldn't be needed if we considered the + // accesskey combination properly. + if (aIsTrustedEvent) { + doc->NotifyUserGestureActivation(); + } + + auto result = + element->PerformAccesskey(shouldActivate, aIsTrustedEvent); + if (result.isOk()) { + if (result.unwrap() && aIsTrustedEvent) { + // If this is a child process, inform the parent that we want the + // focus, but pass false since we don't want to change the window + // order. + nsIDocShell* docShell = mPresContext->GetDocShell(); + nsCOMPtr<nsIBrowserChild> child = + docShell ? docShell->GetBrowserChild() : nullptr; + if (child) { + child->SendRequestFocus(false, CallerType::System); + } + } + return true; + } + } + } + } + return false; +} + +// static +void EventStateManager::GetAccessKeyLabelPrefix(Element* aElement, + nsAString& aPrefix) { + aPrefix.Truncate(); + nsAutoString separator, modifierText; + nsContentUtils::GetModifierSeparatorText(separator); + + AccessKeyType accessKeyType = + GetAccessKeyTypeFor(aElement->OwnerDoc()->GetDocShell()); + if (accessKeyType == AccessKeyType::eNone) { + return; + } + Modifiers modifiers = WidgetKeyboardEvent::AccessKeyModifiers(accessKeyType); + if (modifiers == MODIFIER_NONE) { + return; + } + + if (modifiers & MODIFIER_CONTROL) { + nsContentUtils::GetControlText(modifierText); + aPrefix.Append(modifierText + separator); + } + if (modifiers & MODIFIER_META) { + nsContentUtils::GetCommandOrWinText(modifierText); + aPrefix.Append(modifierText + separator); + } + if (modifiers & MODIFIER_ALT) { + nsContentUtils::GetAltText(modifierText); + aPrefix.Append(modifierText + separator); + } + if (modifiers & MODIFIER_SHIFT) { + nsContentUtils::GetShiftText(modifierText); + aPrefix.Append(modifierText + separator); + } +} + +struct MOZ_STACK_CLASS AccessKeyInfo { + WidgetKeyboardEvent* event; + nsTArray<uint32_t>& charCodes; + + AccessKeyInfo(WidgetKeyboardEvent* aEvent, nsTArray<uint32_t>& aCharCodes) + : event(aEvent), charCodes(aCharCodes) {} +}; + +bool EventStateManager::WalkESMTreeToHandleAccessKey( + WidgetKeyboardEvent* aEvent, nsPresContext* aPresContext, + nsTArray<uint32_t>& aAccessCharCodes, nsIDocShellTreeItem* aBubbledFrom, + ProcessingAccessKeyState aAccessKeyState, bool aExecute) { + EnsureDocument(mPresContext); + nsCOMPtr<nsIDocShell> docShell = aPresContext->GetDocShell(); + if (NS_WARN_IF(!docShell) || NS_WARN_IF(!mDocument)) { + return false; + } + AccessKeyType accessKeyType = GetAccessKeyTypeFor(docShell); + if (accessKeyType == AccessKeyType::eNone) { + return false; + } + // Alt or other accesskey modifier is down, we may need to do an accesskey. + if (mAccessKeys.Count() > 0 && + aEvent->ModifiersMatchWithAccessKey(accessKeyType)) { + // Someone registered an accesskey. Find and activate it. + if (LookForAccessKeyAndExecute(aAccessCharCodes, aEvent->IsTrusted(), + aEvent->mIsRepeat, aExecute)) { + return true; + } + } + + int32_t childCount; + docShell->GetInProcessChildCount(&childCount); + for (int32_t counter = 0; counter < childCount; counter++) { + // Not processing the child which bubbles up the handling + nsCOMPtr<nsIDocShellTreeItem> subShellItem; + docShell->GetInProcessChildAt(counter, getter_AddRefs(subShellItem)); + if (aAccessKeyState == eAccessKeyProcessingUp && + subShellItem == aBubbledFrom) { + continue; + } + + nsCOMPtr<nsIDocShell> subDS = do_QueryInterface(subShellItem); + if (subDS && IsShellVisible(subDS)) { + // Guarantee subPresShell lifetime while we're handling access key + // since somebody may assume that it won't be deleted before the + // corresponding nsPresContext and EventStateManager. + RefPtr<PresShell> subPresShell = subDS->GetPresShell(); + + // Docshells need not have a presshell (eg. display:none + // iframes, docshells in transition between documents, etc). + if (!subPresShell) { + // Oh, well. Just move on to the next child + continue; + } + + RefPtr<nsPresContext> subPresContext = subPresShell->GetPresContext(); + + RefPtr<EventStateManager> esm = + static_cast<EventStateManager*>(subPresContext->EventStateManager()); + + if (esm && esm->WalkESMTreeToHandleAccessKey( + aEvent, subPresContext, aAccessCharCodes, nullptr, + eAccessKeyProcessingDown, aExecute)) { + return true; + } + } + } // if end . checking all sub docshell ends here. + + // bubble up the process to the parent docshell if necessary + if (eAccessKeyProcessingDown != aAccessKeyState) { + nsCOMPtr<nsIDocShellTreeItem> parentShellItem; + docShell->GetInProcessParent(getter_AddRefs(parentShellItem)); + nsCOMPtr<nsIDocShell> parentDS = do_QueryInterface(parentShellItem); + if (parentDS) { + // Guarantee parentPresShell lifetime while we're handling access key + // since somebody may assume that it won't be deleted before the + // corresponding nsPresContext and EventStateManager. + RefPtr<PresShell> parentPresShell = parentDS->GetPresShell(); + NS_ASSERTION(parentPresShell, + "Our PresShell exists but the parent's does not?"); + + RefPtr<nsPresContext> parentPresContext = + parentPresShell->GetPresContext(); + NS_ASSERTION(parentPresContext, "PresShell without PresContext"); + + RefPtr<EventStateManager> esm = static_cast<EventStateManager*>( + parentPresContext->EventStateManager()); + if (esm && esm->WalkESMTreeToHandleAccessKey( + aEvent, parentPresContext, aAccessCharCodes, docShell, + eAccessKeyProcessingDown, aExecute)) { + return true; + } + } + } // if end. bubble up process + + // If the content access key modifier is pressed, try remote children + if (aExecute && + aEvent->ModifiersMatchWithAccessKey(AccessKeyType::eContent) && + mDocument && mDocument->GetWindow()) { + // If the focus is currently on a node with a BrowserParent, the key event + // should've gotten forwarded to the child process and HandleAccessKey + // called from there. + if (BrowserParent::GetFrom(GetFocusedElement())) { + // If access key may be only in remote contents, this method won't handle + // access key synchronously. In this case, only reply event should reach + // here. + MOZ_ASSERT(aEvent->IsHandledInRemoteProcess() || + !aEvent->IsWaitingReplyFromRemoteProcess()); + } + // If focus is somewhere else, then we need to check the remote children. + // However, if the event has already been handled in a remote process, + // then, focus is moved from the remote process after posting the event. + // In such case, we shouldn't retry to handle access keys in remote + // processes. + else if (!aEvent->IsHandledInRemoteProcess()) { + AccessKeyInfo accessKeyInfo(aEvent, aAccessCharCodes); + nsContentUtils::CallOnAllRemoteChildren( + mDocument->GetWindow(), + [&accessKeyInfo](BrowserParent* aBrowserParent) -> CallState { + // Only forward accesskeys for the active tab. + if (aBrowserParent->GetDocShellIsActive()) { + // Even if there is no target for the accesskey in this process, + // the event may match with a content accesskey. If so, the + // keyboard event should be handled with reply event for + // preventing double action. (e.g., Alt+Shift+F on Windows may + // focus a content in remote and open "File" menu.) + accessKeyInfo.event->StopPropagation(); + accessKeyInfo.event->MarkAsWaitingReplyFromRemoteProcess(); + aBrowserParent->HandleAccessKey(*accessKeyInfo.event, + accessKeyInfo.charCodes); + return CallState::Stop; + } + + return CallState::Continue; + }); + } + } + + return false; +} // end of HandleAccessKey + +static BrowserParent* GetBrowserParentAncestor(BrowserParent* aBrowserParent) { + MOZ_ASSERT(aBrowserParent); + + BrowserBridgeParent* bbp = aBrowserParent->GetBrowserBridgeParent(); + if (!bbp) { + return nullptr; + } + + return bbp->Manager(); +} + +static void DispatchCrossProcessMouseExitEvents(WidgetMouseEvent* aMouseEvent, + BrowserParent* aRemoteTarget, + BrowserParent* aStopAncestor, + bool aIsReallyExit) { + MOZ_ASSERT(aMouseEvent); + MOZ_ASSERT(aRemoteTarget); + MOZ_ASSERT(aRemoteTarget != aStopAncestor); + MOZ_ASSERT_IF(aStopAncestor, nsContentUtils::GetCommonBrowserParentAncestor( + aRemoteTarget, aStopAncestor)); + + while (aRemoteTarget != aStopAncestor) { + UniquePtr<WidgetMouseEvent> mouseExitEvent = + CreateMouseOrPointerWidgetEvent(aMouseEvent, eMouseExitFromWidget, + aMouseEvent->mRelatedTarget); + mouseExitEvent->mExitFrom = + Some(aIsReallyExit ? WidgetMouseEvent::ePuppet + : WidgetMouseEvent::ePuppetParentToPuppetChild); + aRemoteTarget->SendRealMouseEvent(*mouseExitEvent); + + aRemoteTarget = GetBrowserParentAncestor(aRemoteTarget); + } +} + +void EventStateManager::DispatchCrossProcessEvent(WidgetEvent* aEvent, + BrowserParent* aRemoteTarget, + nsEventStatus* aStatus) { + MOZ_ASSERT(aEvent); + MOZ_ASSERT(aRemoteTarget); + MOZ_ASSERT(aStatus); + + BrowserParent* remote = aRemoteTarget; + + WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent(); + bool isContextMenuKey = mouseEvent && mouseEvent->IsContextMenuKeyEvent(); + if (aEvent->mClass == eKeyboardEventClass || isContextMenuKey) { + // APZ attaches a LayersId to hit-testable events, for keyboard events, + // we use focus. + BrowserParent* preciseRemote = BrowserParent::GetFocused(); + if (preciseRemote) { + remote = preciseRemote; + } + // else there is a race between layout and focus tracking, + // so fall back to delivering the event to the topmost child process. + } else if (aEvent->mLayersId.IsValid()) { + BrowserParent* preciseRemote = + BrowserParent::GetBrowserParentFromLayersId(aEvent->mLayersId); + if (preciseRemote) { + remote = preciseRemote; + } + // else there is a race between APZ and the LayersId to BrowserParent + // mapping, so fall back to delivering the event to the topmost child + // process. + } + + switch (aEvent->mClass) { + case eMouseEventClass: { + BrowserParent* oldRemote = BrowserParent::GetLastMouseRemoteTarget(); + + // If this is a eMouseExitFromWidget event, need to redirect the event to + // the last remote and and notify all its ancestors about the exit, if + // any. + if (mouseEvent->mMessage == eMouseExitFromWidget) { + MOZ_ASSERT(mouseEvent->mExitFrom.value() == WidgetMouseEvent::ePuppet); + MOZ_ASSERT(mouseEvent->mReason == WidgetMouseEvent::eReal); + MOZ_ASSERT(!mouseEvent->mLayersId.IsValid()); + MOZ_ASSERT(remote->GetBrowserHost()); + + if (oldRemote && oldRemote != remote) { + Unused << NS_WARN_IF(nsContentUtils::GetCommonBrowserParentAncestor( + remote, oldRemote) != remote); + remote = oldRemote; + } + + DispatchCrossProcessMouseExitEvents(mouseEvent, remote, nullptr, true); + return; + } + + if (BrowserParent* pointerLockedRemote = + PointerLockManager::GetLockedRemoteTarget()) { + remote = pointerLockedRemote; + } else if (BrowserParent* pointerCapturedRemote = + PointerEventHandler::GetPointerCapturingRemoteTarget( + mouseEvent->pointerId)) { + remote = pointerCapturedRemote; + } else if (BrowserParent* capturingRemote = + PresShell::GetCapturingRemoteTarget()) { + remote = capturingRemote; + } + + // If a mouse is over a remote target A, and then moves to + // remote target B, we'd deliver the event directly to remote target B + // after the moving, A would never get notified that the mouse left. + // So we generate a exit event to notify A after the move. + // XXXedgar, if the synthesized mouse events could deliver to the correct + // process directly (see + // https://bugzilla.mozilla.org/show_bug.cgi?id=1549355), we probably + // don't need to check mReason then. + if (mouseEvent->mReason == WidgetMouseEvent::eReal && + remote != oldRemote) { + MOZ_ASSERT(mouseEvent->mMessage != eMouseExitFromWidget); + if (oldRemote) { + BrowserParent* commonAncestor = + nsContentUtils::GetCommonBrowserParentAncestor(remote, oldRemote); + if (commonAncestor == oldRemote) { + // Mouse moves to the inner OOP frame, it is not a really exit. + DispatchCrossProcessMouseExitEvents( + mouseEvent, GetBrowserParentAncestor(remote), + GetBrowserParentAncestor(commonAncestor), false); + } else if (commonAncestor == remote) { + // Mouse moves to the outer OOP frame, it is a really exit. + DispatchCrossProcessMouseExitEvents(mouseEvent, oldRemote, + commonAncestor, true); + } else { + // Mouse moves to OOP frame in other subtree, it is a really exit, + // need to notify all its ancestors before common ancestor about the + // exit. + DispatchCrossProcessMouseExitEvents(mouseEvent, oldRemote, + commonAncestor, true); + if (commonAncestor) { + UniquePtr<WidgetMouseEvent> mouseExitEvent = + CreateMouseOrPointerWidgetEvent(mouseEvent, + eMouseExitFromWidget, + mouseEvent->mRelatedTarget); + mouseExitEvent->mExitFrom = + Some(WidgetMouseEvent::ePuppetParentToPuppetChild); + commonAncestor->SendRealMouseEvent(*mouseExitEvent); + } + } + } + + if (mouseEvent->mMessage != eMouseExitFromWidget && + mouseEvent->mMessage != eMouseEnterIntoWidget) { + // This is to make cursor would be updated correctly. + remote->MouseEnterIntoWidget(); + } + } + + remote->SendRealMouseEvent(*mouseEvent); + return; + } + case eKeyboardEventClass: { + auto* keyboardEvent = aEvent->AsKeyboardEvent(); + if (aEvent->mMessage == eKeyUp) { + HandleKeyUpInteraction(keyboardEvent); + } + remote->SendRealKeyEvent(*keyboardEvent); + return; + } + case eWheelEventClass: { + if (BrowserParent* pointerLockedRemote = + PointerLockManager::GetLockedRemoteTarget()) { + remote = pointerLockedRemote; + } + remote->SendMouseWheelEvent(*aEvent->AsWheelEvent()); + return; + } + case eTouchEventClass: { + // Let the child process synthesize a mouse event if needed, and + // ensure we don't synthesize one in this process. + *aStatus = nsEventStatus_eConsumeNoDefault; + remote->SendRealTouchEvent(*aEvent->AsTouchEvent()); + return; + } + case eDragEventClass: { + RefPtr<BrowserParent> browserParent = remote; + browserParent->Manager()->MaybeInvokeDragSession(browserParent, + aEvent->mMessage); + + nsCOMPtr<nsIDragSession> dragSession = nsContentUtils::GetDragSession(); + uint32_t dropEffect = nsIDragService::DRAGDROP_ACTION_NONE; + uint32_t action = nsIDragService::DRAGDROP_ACTION_NONE; + nsCOMPtr<nsIPrincipal> principal; + nsCOMPtr<nsIContentSecurityPolicy> csp; + + if (dragSession) { + dragSession->DragEventDispatchedToChildProcess(); + dragSession->GetDragAction(&action); + dragSession->GetTriggeringPrincipal(getter_AddRefs(principal)); + dragSession->GetCsp(getter_AddRefs(csp)); + RefPtr<DataTransfer> initialDataTransfer = + dragSession->GetDataTransfer(); + if (initialDataTransfer) { + dropEffect = initialDataTransfer->DropEffectInt(); + } + } + + browserParent->SendRealDragEvent(*aEvent->AsDragEvent(), action, + dropEffect, principal, csp); + return; + } + default: { + MOZ_CRASH("Attempt to send non-whitelisted event?"); + } + } +} + +bool EventStateManager::IsRemoteTarget(nsIContent* target) { + return BrowserParent::GetFrom(target) || BrowserBridgeChild::GetFrom(target); +} + +bool EventStateManager::IsTopLevelRemoteTarget(nsIContent* target) { + return !!BrowserParent::GetFrom(target); +} + +bool EventStateManager::HandleCrossProcessEvent(WidgetEvent* aEvent, + nsEventStatus* aStatus) { + if (!aEvent->CanBeSentToRemoteProcess()) { + return false; + } + + MOZ_ASSERT(!aEvent->HasBeenPostedToRemoteProcess(), + "Why do we need to post same event to remote processes again?"); + + // Collect the remote event targets we're going to forward this + // event to. + // + // NB: the elements of |remoteTargets| must be unique, for correctness. + AutoTArray<RefPtr<BrowserParent>, 1> remoteTargets; + if (aEvent->mClass != eTouchEventClass || aEvent->mMessage == eTouchStart) { + // If this event only has one target, and it's remote, add it to + // the array. + nsIFrame* frame = aEvent->mMessage == eDragExit + ? sLastDragOverFrame.GetFrame() + : GetEventTarget(); + nsIContent* target = frame ? frame->GetContent() : nullptr; + if (BrowserParent* remoteTarget = BrowserParent::GetFrom(target)) { + remoteTargets.AppendElement(remoteTarget); + } + } else { + // This is a touch event with possibly multiple touch points. + // Each touch point may have its own target. So iterate through + // all of them and collect the unique set of targets for event + // forwarding. + // + // This loop is similar to the one used in + // PresShell::DispatchTouchEvent(). + const WidgetTouchEvent::TouchArray& touches = + aEvent->AsTouchEvent()->mTouches; + for (uint32_t i = 0; i < touches.Length(); ++i) { + Touch* touch = touches[i]; + // NB: the |mChanged| check is an optimization, subprocesses can + // compute this for themselves. If the touch hasn't changed, we + // may be able to avoid forwarding the event entirely (which is + // not free). + if (!touch || !touch->mChanged) { + continue; + } + nsCOMPtr<EventTarget> targetPtr = touch->mTarget; + if (!targetPtr) { + continue; + } + nsCOMPtr<nsIContent> target = do_QueryInterface(targetPtr); + BrowserParent* remoteTarget = BrowserParent::GetFrom(target); + if (remoteTarget && !remoteTargets.Contains(remoteTarget)) { + remoteTargets.AppendElement(remoteTarget); + } + } + } + + if (remoteTargets.Length() == 0) { + return false; + } + + // Dispatch the event to the remote target. + for (uint32_t i = 0; i < remoteTargets.Length(); ++i) { + DispatchCrossProcessEvent(aEvent, remoteTargets[i], aStatus); + } + return aEvent->HasBeenPostedToRemoteProcess(); +} + +// +// CreateClickHoldTimer +// +// Fire off a timer for determining if the user wants click-hold. This timer +// is a one-shot that will be cancelled when the user moves enough to fire +// a drag. +// +void EventStateManager::CreateClickHoldTimer(nsPresContext* inPresContext, + nsIFrame* inDownFrame, + WidgetGUIEvent* inMouseDownEvent) { + if (!inMouseDownEvent->IsTrusted() || + IsTopLevelRemoteTarget(mGestureDownContent) || + PointerLockManager::IsLocked()) { + return; + } + + // just to be anal (er, safe) + if (mClickHoldTimer) { + mClickHoldTimer->Cancel(); + mClickHoldTimer = nullptr; + } + + // if content clicked on has a popup, don't even start the timer + // since we'll end up conflicting and both will show. + if (mGestureDownContent && + nsContentUtils::HasNonEmptyAttr(mGestureDownContent, kNameSpaceID_None, + nsGkAtoms::popup)) { + return; + } + + int32_t clickHoldDelay = StaticPrefs::ui_click_hold_context_menus_delay(); + NS_NewTimerWithFuncCallback( + getter_AddRefs(mClickHoldTimer), sClickHoldCallback, this, clickHoldDelay, + nsITimer::TYPE_ONE_SHOT, "EventStateManager::CreateClickHoldTimer"); +} // CreateClickHoldTimer + +// +// KillClickHoldTimer +// +// Stop the timer that would show the context menu dead in its tracks +// +void EventStateManager::KillClickHoldTimer() { + if (mClickHoldTimer) { + mClickHoldTimer->Cancel(); + mClickHoldTimer = nullptr; + } +} + +// +// sClickHoldCallback +// +// This fires after the mouse has been down for a certain length of time. +// +void EventStateManager::sClickHoldCallback(nsITimer* aTimer, void* aESM) { + RefPtr<EventStateManager> self = static_cast<EventStateManager*>(aESM); + if (self) { + self->FireContextClick(); + } + + // NOTE: |aTimer| and |self->mAutoHideTimer| are invalid after calling + // ClosePopup(); + +} // sAutoHideCallback + +// +// FireContextClick +// +// If we're this far, our timer has fired, which means the mouse has been down +// for a certain period of time and has not moved enough to generate a +// dragGesture. We can be certain the user wants a context-click at this stage, +// so generate a dom event and fire it in. +// +// After the event fires, check if PreventDefault() has been set on the event +// which means that someone either ate the event or put up a context menu. This +// is our cue to stop tracking the drag gesture. If we always did this, +// draggable items w/out a context menu wouldn't be draggable after a certain +// length of time, which is _not_ what we want. +// +void EventStateManager::FireContextClick() { + if (!mGestureDownContent || !mPresContext || PointerLockManager::IsLocked()) { + return; + } + +#ifdef XP_MACOSX + // Hack to ensure that we don't show a context menu when the user + // let go of the mouse after a long cpu-hogging operation prevented + // us from handling any OS events. See bug 117589. + if (!CGEventSourceButtonState(kCGEventSourceStateCombinedSessionState, + kCGMouseButtonLeft)) + return; +#endif + + nsEventStatus status = nsEventStatus_eIgnore; + + // Dispatch to the DOM. We have to fake out the ESM and tell it that the + // current target frame is actually where the mouseDown occurred, otherwise it + // will use the frame the mouse is currently over which may or may not be + // the same. (Note: saari and I have decided that we don't have to reset + // |mCurrentTarget| when we're through because no one else is doing anything + // more with this event and it will get reset on the very next event to the + // correct frame). + mCurrentTarget = mPresContext->GetPrimaryFrameFor(mGestureDownContent); + // make sure the widget sticks around + nsCOMPtr<nsIWidget> targetWidget; + if (mCurrentTarget && (targetWidget = mCurrentTarget->GetNearestWidget())) { + NS_ASSERTION( + mPresContext == mCurrentTarget->PresContext(), + "a prescontext returned a primary frame that didn't belong to it?"); + + // before dispatching, check that we're not on something that + // doesn't get a context menu + bool allowedToDispatch = true; + + if (mGestureDownContent->IsAnyOfXULElements(nsGkAtoms::scrollbar, + nsGkAtoms::scrollbarbutton, + nsGkAtoms::button)) { + allowedToDispatch = false; + } else if (mGestureDownContent->IsXULElement(nsGkAtoms::toolbarbutton)) { + // a <toolbarbutton> that has the container attribute set + // will already have its own dropdown. + if (nsContentUtils::HasNonEmptyAttr( + mGestureDownContent, kNameSpaceID_None, nsGkAtoms::container)) { + allowedToDispatch = false; + } else { + // If the toolbar button has an open menu, don't attempt to open + // a second menu + if (mGestureDownContent->IsElement() && + mGestureDownContent->AsElement()->AttrValueIs( + kNameSpaceID_None, nsGkAtoms::open, nsGkAtoms::_true, + eCaseMatters)) { + allowedToDispatch = false; + } + } + } else if (mGestureDownContent->IsHTMLElement()) { + nsCOMPtr<nsIFormControl> formCtrl(do_QueryInterface(mGestureDownContent)); + + if (formCtrl) { + allowedToDispatch = + formCtrl->IsTextControl(/*aExcludePassword*/ false) || + formCtrl->ControlType() == FormControlType::InputFile; + } else if (mGestureDownContent->IsAnyOfHTMLElements( + nsGkAtoms::embed, nsGkAtoms::object, nsGkAtoms::label)) { + allowedToDispatch = false; + } + } + + if (allowedToDispatch) { + // init the event while mCurrentTarget is still good + WidgetMouseEvent event(true, eContextMenu, targetWidget, + WidgetMouseEvent::eReal); + event.mClickCount = 1; + FillInEventFromGestureDown(&event); + + // stop selection tracking, we're in control now + if (mCurrentTarget) { + RefPtr<nsFrameSelection> frameSel = mCurrentTarget->GetFrameSelection(); + + if (frameSel && frameSel->GetDragState()) { + // note that this can cause selection changed events to fire if we're + // in a text field, which will null out mCurrentTarget + frameSel->SetDragState(false); + } + } + + AutoHandlingUserInputStatePusher userInpStatePusher(true, &event); + + // dispatch to DOM + RefPtr<nsIContent> gestureDownContent = mGestureDownContent; + RefPtr<nsPresContext> presContext = mPresContext; + EventDispatcher::Dispatch(gestureDownContent, presContext, &event, + nullptr, &status); + + // We don't need to dispatch to frame handling because no frames + // watch eContextMenu except for nsMenuFrame and that's only for + // dismissal. That's just as well since we don't really know + // which frame to send it to. + } + } + + // now check if the event has been handled. If so, stop tracking a drag + if (status == nsEventStatus_eConsumeNoDefault) { + StopTrackingDragGesture(true); + } + + KillClickHoldTimer(); + +} // FireContextClick + +// +// BeginTrackingDragGesture +// +// Record that the mouse has gone down and that we should move to TRACKING state +// of d&d gesture tracker. +// +// We also use this to track click-hold context menus. When the mouse goes down, +// fire off a short timer. If the timer goes off and we have yet to fire the +// drag gesture (ie, the mouse hasn't moved a certain distance), then we can +// assume the user wants a click-hold, so fire a context-click event. We only +// want to cancel the drag gesture if the context-click event is handled. +// +void EventStateManager::BeginTrackingDragGesture(nsPresContext* aPresContext, + WidgetMouseEvent* inDownEvent, + nsIFrame* inDownFrame) { + if (!inDownEvent->mWidget) { + return; + } + + // Note that |inDownEvent| could be either a mouse down event or a + // synthesized mouse move event. + SetGestureDownPoint(inDownEvent); + + if (inDownFrame) { + inDownFrame->GetContentForEvent(inDownEvent, + getter_AddRefs(mGestureDownContent)); + + mGestureDownFrameOwner = inDownFrame->GetContent(); + if (!mGestureDownFrameOwner) { + mGestureDownFrameOwner = mGestureDownContent; + } + } + mGestureModifiers = inDownEvent->mModifiers; + mGestureDownButtons = inDownEvent->mButtons; + + if (inDownEvent->mMessage != eMouseTouchDrag && + StaticPrefs::ui_click_hold_context_menus()) { + // fire off a timer to track click-hold + CreateClickHoldTimer(aPresContext, inDownFrame, inDownEvent); + } +} + +void EventStateManager::SetGestureDownPoint(WidgetGUIEvent* aEvent) { + mGestureDownPoint = + GetEventRefPoint(aEvent) + aEvent->mWidget->WidgetToScreenOffset(); +} + +LayoutDeviceIntPoint EventStateManager::GetEventRefPoint( + WidgetEvent* aEvent) const { + auto touchEvent = aEvent->AsTouchEvent(); + return (touchEvent && !touchEvent->mTouches.IsEmpty()) + ? aEvent->AsTouchEvent()->mTouches[0]->mRefPoint + : aEvent->mRefPoint; +} + +void EventStateManager::BeginTrackingRemoteDragGesture( + nsIContent* aContent, RemoteDragStartData* aDragStartData) { + mGestureDownContent = aContent; + mGestureDownFrameOwner = aContent; + mGestureDownInTextControl = + aContent && aContent->IsInNativeAnonymousSubtree() && + TextControlElement::FromNodeOrNull( + aContent->GetClosestNativeAnonymousSubtreeRootParentOrHost()); + mGestureDownDragStartData = aDragStartData; +} + +// +// StopTrackingDragGesture +// +// Record that the mouse has gone back up so that we should leave the TRACKING +// state of d&d gesture tracker and return to the START state. +// +void EventStateManager::StopTrackingDragGesture(bool aClearInChildProcesses) { + mGestureDownContent = nullptr; + mGestureDownFrameOwner = nullptr; + mGestureDownInTextControl = false; + mGestureDownDragStartData = nullptr; + + // If a content process starts a drag but the mouse is released before the + // parent starts the actual drag, the content process will think a drag is + // still happening. Inform any child processes with active drags that the drag + // should be stopped. + if (aClearInChildProcesses) { + nsCOMPtr<nsIDragService> dragService = + do_GetService("@mozilla.org/widget/dragservice;1"); + if (dragService) { + nsCOMPtr<nsIDragSession> dragSession; + dragService->GetCurrentSession(getter_AddRefs(dragSession)); + if (!dragSession) { + // Only notify if there isn't a drag session active. + dragService->RemoveAllChildProcesses(); + } + } + } +} + +void EventStateManager::FillInEventFromGestureDown(WidgetMouseEvent* aEvent) { + NS_ASSERTION(aEvent->mWidget == mCurrentTarget->GetNearestWidget(), + "Incorrect widget in event"); + + // Set the coordinates in the new event to the coordinates of + // the old event, adjusted for the fact that the widget might be + // different + aEvent->mRefPoint = + mGestureDownPoint - aEvent->mWidget->WidgetToScreenOffset(); + aEvent->mModifiers = mGestureModifiers; + aEvent->mButtons = mGestureDownButtons; +} + +void EventStateManager::MaybeFirePointerCancel(WidgetInputEvent* aEvent) { + RefPtr<PresShell> presShell = mPresContext->GetPresShell(); + AutoWeakFrame targetFrame = mCurrentTarget; + + if (!presShell || !targetFrame) { + return; + } + + nsCOMPtr<nsIContent> content; + targetFrame->GetContentForEvent(aEvent, getter_AddRefs(content)); + if (!content) { + return; + } + + nsEventStatus status = nsEventStatus_eIgnore; + + if (WidgetMouseEvent* aMouseEvent = aEvent->AsMouseEvent()) { + WidgetPointerEvent event(*aMouseEvent); + PointerEventHandler::InitPointerEventFromMouse(&event, aMouseEvent, + ePointerCancel); + + event.convertToPointer = false; + presShell->HandleEventWithTarget(&event, targetFrame, content, &status); + } else if (WidgetTouchEvent* aTouchEvent = aEvent->AsTouchEvent()) { + WidgetPointerEvent event(aTouchEvent->IsTrusted(), ePointerCancel, + aTouchEvent->mWidget); + + PointerEventHandler::InitPointerEventFromTouch( + event, *aTouchEvent, *aTouchEvent->mTouches[0], true); + + event.convertToPointer = false; + presShell->HandleEventWithTarget(&event, targetFrame, content, &status); + } else { + MOZ_ASSERT(false); + } + + // HandleEventWithTarget clears out mCurrentTarget, which may be used in the + // caller GenerateDragGesture. We have to restore mCurrentTarget. + mCurrentTarget = targetFrame; +} + +bool EventStateManager::IsEventOutsideDragThreshold( + WidgetInputEvent* aEvent) const { + static int32_t sPixelThresholdX = 0; + static int32_t sPixelThresholdY = 0; + + if (!sPixelThresholdX) { + sPixelThresholdX = + LookAndFeel::GetInt(LookAndFeel::IntID::DragThresholdX, 0); + sPixelThresholdY = + LookAndFeel::GetInt(LookAndFeel::IntID::DragThresholdY, 0); + if (sPixelThresholdX <= 0) { + sPixelThresholdX = 5; + } + if (sPixelThresholdY <= 0) { + sPixelThresholdY = 5; + } + } + + LayoutDeviceIntPoint pt = + aEvent->mWidget->WidgetToScreenOffset() + GetEventRefPoint(aEvent); + LayoutDeviceIntPoint distance = pt - mGestureDownPoint; + return Abs(distance.x) > sPixelThresholdX || + Abs(distance.y) > sPixelThresholdY; +} + +// +// GenerateDragGesture +// +// If we're in the TRACKING state of the d&d gesture tracker, check the current +// position of the mouse in relation to the old one. If we've moved a sufficient +// amount from the mouse down, then fire off a drag gesture event. +void EventStateManager::GenerateDragGesture(nsPresContext* aPresContext, + WidgetInputEvent* aEvent) { + NS_ASSERTION(aPresContext, "This shouldn't happen."); + if (!IsTrackingDragGesture()) { + return; + } + + AutoWeakFrame targetFrameBefore = mCurrentTarget; + auto autoRestore = MakeScopeExit([&] { mCurrentTarget = targetFrameBefore; }); + mCurrentTarget = mGestureDownFrameOwner->GetPrimaryFrame(); + + if (!mCurrentTarget || !mCurrentTarget->GetNearestWidget()) { + StopTrackingDragGesture(true); + return; + } + + // Check if selection is tracking drag gestures, if so + // don't interfere! + if (mCurrentTarget) { + RefPtr<nsFrameSelection> frameSel = mCurrentTarget->GetFrameSelection(); + if (frameSel && frameSel->GetDragState()) { + StopTrackingDragGesture(true); + return; + } + } + + // If non-native code is capturing the mouse don't start a drag. + if (PresShell::IsMouseCapturePreventingDrag()) { + StopTrackingDragGesture(true); + return; + } + + if (!IsEventOutsideDragThreshold(aEvent)) { + // To keep the old behavior, flush layout even if we don't start dnd. + FlushLayout(aPresContext); + return; + } + + if (StaticPrefs::ui_click_hold_context_menus()) { + // stop the click-hold before we fire off the drag gesture, in case + // it takes a long time + KillClickHoldTimer(); + } + + nsCOMPtr<nsIDocShell> docshell = aPresContext->GetDocShell(); + if (!docshell) { + return; + } + + nsCOMPtr<nsPIDOMWindowOuter> window = docshell->GetWindow(); + if (!window) return; + + RefPtr<DataTransfer> dataTransfer = + new DataTransfer(window, eDragStart, false, -1); + auto protectDataTransfer = MakeScopeExit([&] { + if (dataTransfer) { + dataTransfer->Disconnect(); + } + }); + + RefPtr<Selection> selection; + RefPtr<RemoteDragStartData> remoteDragStartData; + nsCOMPtr<nsIContent> eventContent, targetContent; + nsCOMPtr<nsIPrincipal> principal; + nsCOMPtr<nsIContentSecurityPolicy> csp; + nsCOMPtr<nsICookieJarSettings> cookieJarSettings; + bool allowEmptyDataTransfer = false; + mCurrentTarget->GetContentForEvent(aEvent, getter_AddRefs(eventContent)); + if (eventContent) { + // If the content is a text node in a password field, we shouldn't + // allow to drag its raw text. Note that we've supported drag from + // password fields but dragging data was masked text. So, it doesn't + // make sense anyway. + if (eventContent->IsText() && eventContent->HasFlag(NS_MAYBE_MASKED)) { + // However, it makes sense to allow to drag selected password text + // when copying selected password is allowed because users may want + // to use drag and drop rather than copy and paste when web apps + // request to input password twice for conforming new password but + // they used password generator. + TextEditor* textEditor = + nsContentUtils::GetTextEditorFromAnonymousNodeWithoutCreation( + eventContent); + if (!textEditor || !textEditor->IsCopyToClipboardAllowed()) { + StopTrackingDragGesture(true); + return; + } + } + DetermineDragTargetAndDefaultData( + window, eventContent, dataTransfer, &allowEmptyDataTransfer, + getter_AddRefs(selection), getter_AddRefs(remoteDragStartData), + getter_AddRefs(targetContent), getter_AddRefs(principal), + getter_AddRefs(csp), getter_AddRefs(cookieJarSettings)); + } + + // Stop tracking the drag gesture now. This should stop us from + // reentering GenerateDragGesture inside DOM event processing. + // Pass false to avoid clearing the child process state since a real + // drag should be starting. + StopTrackingDragGesture(false); + + if (!targetContent) return; + + // Use our targetContent, now that we've determined it, as the + // parent object of the DataTransfer. + nsCOMPtr<nsIContent> parentContent = + targetContent->FindFirstNonChromeOnlyAccessContent(); + dataTransfer->SetParentObject(parentContent); + + sLastDragOverFrame = nullptr; + nsCOMPtr<nsIWidget> widget = mCurrentTarget->GetNearestWidget(); + + // get the widget from the target frame + WidgetDragEvent startEvent(aEvent->IsTrusted(), eDragStart, widget); + startEvent.mFlags.mIsSynthesizedForTests = + aEvent->mFlags.mIsSynthesizedForTests; + FillInEventFromGestureDown(&startEvent); + + startEvent.mDataTransfer = dataTransfer; + if (aEvent->AsMouseEvent()) { + startEvent.mInputSource = aEvent->AsMouseEvent()->mInputSource; + } else if (aEvent->AsTouchEvent()) { + startEvent.mInputSource = MouseEvent_Binding::MOZ_SOURCE_TOUCH; + } else { + MOZ_ASSERT(false); + } + + // Dispatch to the DOM. By setting mCurrentTarget we are faking + // out the ESM and telling it that the current target frame is + // actually where the mouseDown occurred, otherwise it will use + // the frame the mouse is currently over which may or may not be + // the same. + + // Hold onto old target content through the event and reset after. + nsCOMPtr<nsIContent> targetBeforeEvent = mCurrentTargetContent; + + // Set the current target to the content for the mouse down + mCurrentTargetContent = targetContent; + + // Dispatch the dragstart event to the DOM. + nsEventStatus status = nsEventStatus_eIgnore; + EventDispatcher::Dispatch(targetContent, aPresContext, &startEvent, nullptr, + &status); + + WidgetDragEvent* event = &startEvent; + + nsCOMPtr<nsIObserverService> observerService = + mozilla::services::GetObserverService(); + // Emit observer event to allow addons to modify the DataTransfer + // object. + if (observerService) { + observerService->NotifyObservers(dataTransfer, "on-datatransfer-available", + nullptr); + } + + if (status != nsEventStatus_eConsumeNoDefault) { + bool dragStarted = DoDefaultDragStart(aPresContext, event, dataTransfer, + allowEmptyDataTransfer, targetContent, + selection, remoteDragStartData, + principal, csp, cookieJarSettings); + if (dragStarted) { + sActiveESM = nullptr; + MaybeFirePointerCancel(aEvent); + aEvent->StopPropagation(); + } + } + + // Reset mCurretTargetContent to what it was + mCurrentTargetContent = targetBeforeEvent; + + // Now flush all pending notifications, for better responsiveness + // while dragging. + FlushLayout(aPresContext); +} // GenerateDragGesture + +void EventStateManager::DetermineDragTargetAndDefaultData( + nsPIDOMWindowOuter* aWindow, nsIContent* aSelectionTarget, + DataTransfer* aDataTransfer, bool* aAllowEmptyDataTransfer, + Selection** aSelection, RemoteDragStartData** aRemoteDragStartData, + nsIContent** aTargetNode, nsIPrincipal** aPrincipal, + nsIContentSecurityPolicy** aCsp, + nsICookieJarSettings** aCookieJarSettings) { + *aTargetNode = nullptr; + *aAllowEmptyDataTransfer = false; + nsCOMPtr<nsIContent> dragDataNode; + + nsIContent* editingElement = aSelectionTarget->IsEditable() + ? aSelectionTarget->GetEditingHost() + : nullptr; + + // In chrome, only allow dragging inside editable areas. + bool isChromeContext = !aWindow->GetBrowsingContext()->IsContent(); + if (isChromeContext && !editingElement) { + if (mGestureDownDragStartData) { + // A child process started a drag so use any data it assigned for the dnd + // session. + mGestureDownDragStartData->AddInitialDnDDataTo(aDataTransfer, aPrincipal, + aCsp, aCookieJarSettings); + mGestureDownDragStartData.forget(aRemoteDragStartData); + *aAllowEmptyDataTransfer = true; + } + } else { + mGestureDownDragStartData = nullptr; + + // GetDragData determines if a selection, link or image in the content + // should be dragged, and places the data associated with the drag in the + // data transfer. + // mGestureDownContent is the node where the mousedown event for the drag + // occurred, and aSelectionTarget is the node to use when a selection is + // used + bool canDrag; + bool wasAlt = (mGestureModifiers & MODIFIER_ALT) != 0; + nsresult rv = nsContentAreaDragDrop::GetDragData( + aWindow, mGestureDownContent, aSelectionTarget, wasAlt, aDataTransfer, + &canDrag, aSelection, getter_AddRefs(dragDataNode), aCsp, + aCookieJarSettings); + if (NS_FAILED(rv) || !canDrag) { + return; + } + } + + // if GetDragData returned a node, use that as the node being dragged. + // Otherwise, if a selection is being dragged, use the node within the + // selection that was dragged. Otherwise, just use the mousedown target. + nsIContent* dragContent = mGestureDownContent; + if (dragDataNode) + dragContent = dragDataNode; + else if (*aSelection) + dragContent = aSelectionTarget; + + nsIContent* originalDragContent = dragContent; + + // If a selection isn't being dragged, look for an ancestor with the + // draggable property set. If one is found, use that as the target of the + // drag instead of the node that was clicked on. If a draggable node wasn't + // found, just use the clicked node. + if (!*aSelection) { + while (dragContent) { + if (auto htmlElement = nsGenericHTMLElement::FromNode(dragContent)) { + if (htmlElement->Draggable()) { + // We let draggable elements to trigger dnd even if there is no data + // in the DataTransfer. + *aAllowEmptyDataTransfer = true; + break; + } + } else { + if (dragContent->IsXULElement()) { + // All XUL elements are draggable, so if a XUL element is + // encountered, stop looking for draggable nodes and just use the + // original clicked node instead. + // XXXndeakin + // In the future, we will want to improve this so that XUL has a + // better way to specify whether something is draggable than just + // on/off. + dragContent = mGestureDownContent; + break; + } + // otherwise, it's not an HTML or XUL element, so just keep looking + } + dragContent = dragContent->GetFlattenedTreeParent(); + } + } + + // if no node in the hierarchy was found to drag, but the GetDragData method + // returned a node, use that returned node. Otherwise, nothing is draggable. + if (!dragContent && dragDataNode) dragContent = dragDataNode; + + if (dragContent) { + // if an ancestor node was used instead, clear the drag data + // XXXndeakin rework this a bit. Find a way to just not call GetDragData if + // we don't need to. + if (dragContent != originalDragContent) aDataTransfer->ClearAll(); + *aTargetNode = dragContent; + NS_ADDREF(*aTargetNode); + } +} + +bool EventStateManager::DoDefaultDragStart( + nsPresContext* aPresContext, WidgetDragEvent* aDragEvent, + DataTransfer* aDataTransfer, bool aAllowEmptyDataTransfer, + nsIContent* aDragTarget, Selection* aSelection, + RemoteDragStartData* aDragStartData, nsIPrincipal* aPrincipal, + nsIContentSecurityPolicy* aCsp, nsICookieJarSettings* aCookieJarSettings) { + nsCOMPtr<nsIDragService> dragService = + do_GetService("@mozilla.org/widget/dragservice;1"); + if (!dragService) return false; + + // Default handling for the dragstart event. + // + // First, check if a drag session already exists. This means that the drag + // service was called directly within a draggesture handler. In this case, + // don't do anything more, as it is assumed that the handler is managing + // drag and drop manually. Make sure to return true to indicate that a drag + // began. However, if we're handling drag session for synthesized events, + // we need to initialize some information of the session. Therefore, we + // need to keep going for synthesized case. + nsCOMPtr<nsIDragSession> dragSession; + dragService->GetCurrentSession(getter_AddRefs(dragSession)); + if (dragSession && !dragSession->IsSynthesizedForTests()) { + return true; + } + + // No drag session is currently active, so check if a handler added + // any items to be dragged. If not, there isn't anything to drag. + uint32_t count = 0; + if (aDataTransfer) { + count = aDataTransfer->MozItemCount(); + } + if (!aAllowEmptyDataTransfer && !count) { + return false; + } + + // Get the target being dragged, which may not be the same as the + // target of the mouse event. If one wasn't set in the + // aDataTransfer during the event handler, just use the original + // target instead. + nsCOMPtr<nsIContent> dragTarget = aDataTransfer->GetDragTarget(); + if (!dragTarget) { + dragTarget = aDragTarget; + if (!dragTarget) { + return false; + } + } + + // check which drag effect should initially be used. If the effect was not + // set, just use all actions, otherwise Windows won't allow a drop. + uint32_t action = aDataTransfer->EffectAllowedInt(); + if (action == nsIDragService::DRAGDROP_ACTION_UNINITIALIZED) { + action = nsIDragService::DRAGDROP_ACTION_COPY | + nsIDragService::DRAGDROP_ACTION_MOVE | + nsIDragService::DRAGDROP_ACTION_LINK; + } + + // get any custom drag image that was set + int32_t imageX, imageY; + RefPtr<Element> dragImage = aDataTransfer->GetDragImage(&imageX, &imageY); + + nsCOMPtr<nsIArray> transArray = aDataTransfer->GetTransferables(dragTarget); + if (!transArray) { + return false; + } + + RefPtr<DataTransfer> dataTransfer; + if (!dragSession) { + // After this function returns, the DataTransfer will be cleared so it + // appears empty to content. We need to pass a DataTransfer into the Drag + // Session, so we need to make a copy. + aDataTransfer->Clone(aDragTarget, eDrop, aDataTransfer->MozUserCancelled(), + false, getter_AddRefs(dataTransfer)); + + // Copy over the drop effect, as Clone doesn't copy it for us. + dataTransfer->SetDropEffectInt(aDataTransfer->DropEffectInt()); + } else { + MOZ_ASSERT(dragSession->IsSynthesizedForTests()); + MOZ_ASSERT(aDragEvent->mFlags.mIsSynthesizedForTests); + // If we're initializing synthesized drag session, we should use given + // DataTransfer as is because it'll be used with following drag events + // in any tests, therefore it should be set to nsIDragSession.dataTransfer + // because it and DragEvent.dataTransfer should be same instance. + dataTransfer = aDataTransfer; + } + + // XXXndeakin don't really want to create a new drag DOM event + // here, but we need something to pass to the InvokeDragSession + // methods. + RefPtr<DragEvent> event = + NS_NewDOMDragEvent(dragTarget, aPresContext, aDragEvent); + + // Use InvokeDragSessionWithSelection if a selection is being dragged, + // such that the image can be generated from the selected text. However, + // use InvokeDragSessionWithImage if a custom image was set or something + // other than a selection is being dragged. + if (!dragImage && aSelection) { + dragService->InvokeDragSessionWithSelection(aSelection, aPrincipal, aCsp, + aCookieJarSettings, transArray, + action, event, dataTransfer); + } else if (aDragStartData) { + MOZ_ASSERT(XRE_IsParentProcess()); + dragService->InvokeDragSessionWithRemoteImage( + dragTarget, aPrincipal, aCsp, aCookieJarSettings, transArray, action, + aDragStartData, event, dataTransfer); + } else { + dragService->InvokeDragSessionWithImage( + dragTarget, aPrincipal, aCsp, aCookieJarSettings, transArray, action, + dragImage, imageX, imageY, event, dataTransfer); + } + + return true; +} + +void EventStateManager::ChangeZoom(bool aIncrease) { + // Send the zoom change to the top level browser so it will be handled by the + // front end in the same way as other zoom actions. + nsIDocShell* docShell = mDocument->GetDocShell(); + if (!docShell) { + return; + } + + BrowsingContext* bc = docShell->GetBrowsingContext(); + if (!bc) { + return; + } + + if (XRE_IsParentProcess()) { + bc->Canonical()->DispatchWheelZoomChange(aIncrease); + } else if (BrowserChild* child = BrowserChild::GetFrom(docShell)) { + child->SendWheelZoomChange(aIncrease); + } +} + +void EventStateManager::DoScrollHistory(int32_t direction) { + nsCOMPtr<nsISupports> pcContainer(mPresContext->GetContainerWeak()); + if (pcContainer) { + nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(pcContainer)); + if (webNav) { + // positive direction to go back one step, nonpositive to go forward + // This is doing user-initiated history traversal, hence we want + // to require that history entries we navigate to have user interaction. + if (direction > 0) + webNav->GoBack(StaticPrefs::browser_navigation_requireUserInteraction(), + true); + else + webNav->GoForward( + StaticPrefs::browser_navigation_requireUserInteraction(), true); + } + } +} + +void EventStateManager::DoScrollZoom(nsIFrame* aTargetFrame, + int32_t adjustment) { + // Exclude content in chrome docshells. + nsIContent* content = aTargetFrame->GetContent(); + if (content && !nsContentUtils::IsInChromeDocshell(content->OwnerDoc())) { + // Positive adjustment to decrease zoom, negative to increase + const bool increase = adjustment <= 0; + EnsureDocument(mPresContext); + ChangeZoom(increase); + } +} + +static nsIFrame* GetParentFrameToScroll(nsIFrame* aFrame) { + if (!aFrame) return nullptr; + + if (aFrame->StyleDisplay()->mPosition == StylePositionProperty::Fixed && + nsLayoutUtils::IsReallyFixedPos(aFrame)) + return aFrame->PresShell()->GetRootScrollFrame(); + + return aFrame->GetParent(); +} + +void EventStateManager::DispatchLegacyMouseScrollEvents( + nsIFrame* aTargetFrame, WidgetWheelEvent* aEvent, nsEventStatus* aStatus) { + MOZ_ASSERT(aEvent); + MOZ_ASSERT(aStatus); + + if (!aTargetFrame || *aStatus == nsEventStatus_eConsumeNoDefault) { + return; + } + + // Ignore mouse wheel transaction for computing legacy mouse wheel + // events' delta value. + // DOM event's delta vales are computed from CSS pixels. + auto scrollAmountInCSSPixels = + CSSIntSize::FromAppUnitsRounded(aEvent->mScrollAmount); + + // XXX We don't deal with fractional amount in legacy event, though the + // default action handler (DoScrollText()) deals with it. + // If we implemented such strict computation, we would need additional + // accumulated delta values. It would made the code more complicated. + // And also it would computes different delta values from older version. + // It doesn't make sense to implement such code for legacy events and + // rare cases. + int32_t scrollDeltaX, scrollDeltaY, pixelDeltaX, pixelDeltaY; + switch (aEvent->mDeltaMode) { + case WheelEvent_Binding::DOM_DELTA_PAGE: + scrollDeltaX = !aEvent->mLineOrPageDeltaX + ? 0 + : (aEvent->mLineOrPageDeltaX > 0 + ? UIEvent_Binding::SCROLL_PAGE_DOWN + : UIEvent_Binding::SCROLL_PAGE_UP); + scrollDeltaY = !aEvent->mLineOrPageDeltaY + ? 0 + : (aEvent->mLineOrPageDeltaY > 0 + ? UIEvent_Binding::SCROLL_PAGE_DOWN + : UIEvent_Binding::SCROLL_PAGE_UP); + pixelDeltaX = RoundDown(aEvent->mDeltaX * scrollAmountInCSSPixels.width); + pixelDeltaY = RoundDown(aEvent->mDeltaY * scrollAmountInCSSPixels.height); + break; + + case WheelEvent_Binding::DOM_DELTA_LINE: + scrollDeltaX = aEvent->mLineOrPageDeltaX; + scrollDeltaY = aEvent->mLineOrPageDeltaY; + pixelDeltaX = RoundDown(aEvent->mDeltaX * scrollAmountInCSSPixels.width); + pixelDeltaY = RoundDown(aEvent->mDeltaY * scrollAmountInCSSPixels.height); + break; + + case WheelEvent_Binding::DOM_DELTA_PIXEL: + scrollDeltaX = aEvent->mLineOrPageDeltaX; + scrollDeltaY = aEvent->mLineOrPageDeltaY; + pixelDeltaX = RoundDown(aEvent->mDeltaX); + pixelDeltaY = RoundDown(aEvent->mDeltaY); + break; + + default: + MOZ_CRASH("Invalid deltaMode value comes"); + } + + // Send the legacy events in following order: + // 1. Vertical scroll + // 2. Vertical pixel scroll (even if #1 isn't consumed) + // 3. Horizontal scroll (even if #1 and/or #2 are consumed) + // 4. Horizontal pixel scroll (even if #3 isn't consumed) + + AutoWeakFrame targetFrame(aTargetFrame); + + MOZ_ASSERT(*aStatus != nsEventStatus_eConsumeNoDefault && + !aEvent->DefaultPrevented(), + "If you make legacy events dispatched for default prevented wheel " + "event, you need to initialize stateX and stateY"); + EventState stateX, stateY; + if (scrollDeltaY) { + SendLineScrollEvent(aTargetFrame, aEvent, stateY, scrollDeltaY, + DELTA_DIRECTION_Y); + if (!targetFrame.IsAlive()) { + *aStatus = nsEventStatus_eConsumeNoDefault; + return; + } + } + + if (pixelDeltaY) { + SendPixelScrollEvent(aTargetFrame, aEvent, stateY, pixelDeltaY, + DELTA_DIRECTION_Y); + if (!targetFrame.IsAlive()) { + *aStatus = nsEventStatus_eConsumeNoDefault; + return; + } + } + + if (scrollDeltaX) { + SendLineScrollEvent(aTargetFrame, aEvent, stateX, scrollDeltaX, + DELTA_DIRECTION_X); + if (!targetFrame.IsAlive()) { + *aStatus = nsEventStatus_eConsumeNoDefault; + return; + } + } + + if (pixelDeltaX) { + SendPixelScrollEvent(aTargetFrame, aEvent, stateX, pixelDeltaX, + DELTA_DIRECTION_X); + if (!targetFrame.IsAlive()) { + *aStatus = nsEventStatus_eConsumeNoDefault; + return; + } + } + + if (stateY.mDefaultPrevented) { + *aStatus = nsEventStatus_eConsumeNoDefault; + aEvent->PreventDefault(!stateY.mDefaultPreventedByContent); + } + + if (stateX.mDefaultPrevented) { + *aStatus = nsEventStatus_eConsumeNoDefault; + aEvent->PreventDefault(!stateX.mDefaultPreventedByContent); + } +} + +void EventStateManager::SendLineScrollEvent(nsIFrame* aTargetFrame, + WidgetWheelEvent* aEvent, + EventState& aState, int32_t aDelta, + DeltaDirection aDeltaDirection) { + nsCOMPtr<nsIContent> targetContent = aTargetFrame->GetContent(); + if (!targetContent) { + targetContent = GetFocusedElement(); + if (!targetContent) { + return; + } + } + + while (targetContent->IsText()) { + targetContent = targetContent->GetFlattenedTreeParent(); + } + + WidgetMouseScrollEvent event(aEvent->IsTrusted(), + eLegacyMouseLineOrPageScroll, aEvent->mWidget); + event.mFlags.mDefaultPrevented = aState.mDefaultPrevented; + event.mFlags.mDefaultPreventedByContent = aState.mDefaultPreventedByContent; + event.mRefPoint = aEvent->mRefPoint; + event.mTimeStamp = aEvent->mTimeStamp; + event.mModifiers = aEvent->mModifiers; + event.mButtons = aEvent->mButtons; + event.mIsHorizontal = (aDeltaDirection == DELTA_DIRECTION_X); + event.mDelta = aDelta; + event.mInputSource = aEvent->mInputSource; + + RefPtr<nsPresContext> presContext = aTargetFrame->PresContext(); + nsEventStatus status = nsEventStatus_eIgnore; + EventDispatcher::Dispatch(targetContent, presContext, &event, nullptr, + &status); + aState.mDefaultPrevented = + event.DefaultPrevented() || status == nsEventStatus_eConsumeNoDefault; + aState.mDefaultPreventedByContent = event.DefaultPreventedByContent(); +} + +void EventStateManager::SendPixelScrollEvent(nsIFrame* aTargetFrame, + WidgetWheelEvent* aEvent, + EventState& aState, + int32_t aPixelDelta, + DeltaDirection aDeltaDirection) { + nsCOMPtr<nsIContent> targetContent = aTargetFrame->GetContent(); + if (!targetContent) { + targetContent = GetFocusedElement(); + if (!targetContent) { + return; + } + } + + while (targetContent->IsText()) { + targetContent = targetContent->GetFlattenedTreeParent(); + } + + WidgetMouseScrollEvent event(aEvent->IsTrusted(), eLegacyMousePixelScroll, + aEvent->mWidget); + event.mFlags.mDefaultPrevented = aState.mDefaultPrevented; + event.mFlags.mDefaultPreventedByContent = aState.mDefaultPreventedByContent; + event.mRefPoint = aEvent->mRefPoint; + event.mTimeStamp = aEvent->mTimeStamp; + event.mModifiers = aEvent->mModifiers; + event.mButtons = aEvent->mButtons; + event.mIsHorizontal = (aDeltaDirection == DELTA_DIRECTION_X); + event.mDelta = aPixelDelta; + event.mInputSource = aEvent->mInputSource; + + RefPtr<nsPresContext> presContext = aTargetFrame->PresContext(); + nsEventStatus status = nsEventStatus_eIgnore; + EventDispatcher::Dispatch(targetContent, presContext, &event, nullptr, + &status); + aState.mDefaultPrevented = + event.DefaultPrevented() || status == nsEventStatus_eConsumeNoDefault; + aState.mDefaultPreventedByContent = event.DefaultPreventedByContent(); +} + +nsIFrame* EventStateManager::ComputeScrollTargetAndMayAdjustWheelEvent( + nsIFrame* aTargetFrame, WidgetWheelEvent* aEvent, + ComputeScrollTargetOptions aOptions) { + return ComputeScrollTargetAndMayAdjustWheelEvent( + aTargetFrame, aEvent->mDeltaX, aEvent->mDeltaY, aEvent, aOptions); +} + +// Overload ComputeScrollTargetAndMayAdjustWheelEvent method to allow passing +// "test" dx and dy when looking for which scrollbarmediators to activate when +// two finger down on trackpad and before any actual motion +nsIFrame* EventStateManager::ComputeScrollTargetAndMayAdjustWheelEvent( + nsIFrame* aTargetFrame, double aDirectionX, double aDirectionY, + WidgetWheelEvent* aEvent, ComputeScrollTargetOptions aOptions) { + bool isAutoDir = false; + bool honoursRoot = false; + if (MAY_BE_ADJUSTED_BY_AUTO_DIR & aOptions) { + // If the scroll is respected as auto-dir, aDirection* should always be + // equivalent to the event's delta vlaues(Currently, there are only one case + // where aDirection*s have different values from the widget wheel event's + // original delta values and the only case isn't auto-dir, see + // ScrollbarsForWheel::TemporarilyActivateAllPossibleScrollTargets). + MOZ_ASSERT(aDirectionX == aEvent->mDeltaX && + aDirectionY == aEvent->mDeltaY); + + WheelDeltaAdjustmentStrategy strategy = + GetWheelDeltaAdjustmentStrategy(*aEvent); + switch (strategy) { + case WheelDeltaAdjustmentStrategy::eAutoDir: + isAutoDir = true; + honoursRoot = false; + break; + case WheelDeltaAdjustmentStrategy::eAutoDirWithRootHonour: + isAutoDir = true; + honoursRoot = true; + break; + default: + break; + } + } + + if (aOptions & PREFER_MOUSE_WHEEL_TRANSACTION) { + // If the user recently scrolled with the mousewheel, then they probably + // want to scroll the same view as before instead of the view under the + // cursor. WheelTransaction tracks the frame currently being + // scrolled with the mousewheel. We consider the transaction ended when the + // mouse moves more than "mousewheel.transaction.ignoremovedelay" + // milliseconds after the last scroll operation, or any time the mouse moves + // out of the frame, or when more than "mousewheel.transaction.timeout" + // milliseconds have passed after the last operation, even if the mouse + // hasn't moved. + nsIFrame* lastScrollFrame = WheelTransaction::GetScrollTargetFrame(); + if (lastScrollFrame) { + nsIScrollableFrame* scrollableFrame = + lastScrollFrame->GetScrollTargetFrame(); + if (scrollableFrame) { + nsIFrame* frameToScroll = do_QueryFrame(scrollableFrame); + MOZ_ASSERT(frameToScroll); + if (isAutoDir) { + ESMAutoDirWheelDeltaAdjuster adjuster(*aEvent, *lastScrollFrame, + honoursRoot); + // Note that calling this function will not always cause the delta to + // be adjusted, it only adjusts the delta when it should, because + // Adjust() internally calls ShouldBeAdjusted() before making + // adjustment. + adjuster.Adjust(); + } + return frameToScroll; + } + } + } + + // If the event doesn't cause scroll actually, we cannot find scroll target + // because we check if the event can cause scroll actually on each found + // scrollable frame. + if (!aDirectionX && !aDirectionY) { + return nullptr; + } + + bool checkIfScrollableX; + bool checkIfScrollableY; + if (isAutoDir) { + // Always check the frame's scrollability in both the two directions for an + // auto-dir scroll. That is, for an auto-dir scroll, + // PREFER_ACTUAL_SCROLLABLE_TARGET_ALONG_X_AXIS and + // PREFER_ACTUAL_SCROLLABLE_TARGET_ALONG_Y_AXIS should be ignored. + checkIfScrollableX = true; + checkIfScrollableY = true; + } else { + checkIfScrollableX = + aDirectionX && + (aOptions & PREFER_ACTUAL_SCROLLABLE_TARGET_ALONG_X_AXIS); + checkIfScrollableY = + aDirectionY && + (aOptions & PREFER_ACTUAL_SCROLLABLE_TARGET_ALONG_Y_AXIS); + } + + nsIFrame* scrollFrame = !(aOptions & START_FROM_PARENT) + ? aTargetFrame + : GetParentFrameToScroll(aTargetFrame); + for (; scrollFrame; scrollFrame = GetParentFrameToScroll(scrollFrame)) { + // Check whether the frame wants to provide us with a scrollable view. + nsIScrollableFrame* scrollableFrame = scrollFrame->GetScrollTargetFrame(); + if (!scrollableFrame) { + nsMenuPopupFrame* menuPopupFrame = do_QueryFrame(scrollFrame); + if (menuPopupFrame) { + return nullptr; + } + continue; + } + + nsIFrame* frameToScroll = do_QueryFrame(scrollableFrame); + MOZ_ASSERT(frameToScroll); + + if (!checkIfScrollableX && !checkIfScrollableY) { + return frameToScroll; + } + + // If the frame disregards the direction the user is trying to scroll, then + // it should just bubbles the scroll event up to its parental scroll frame + + Maybe<layers::ScrollDirection> disregardedDirection = + WheelHandlingUtils::GetDisregardedWheelScrollDirection(scrollFrame); + if (disregardedDirection) { + switch (disregardedDirection.ref()) { + case layers::ScrollDirection::eHorizontal: + if (checkIfScrollableX) { + continue; + } + break; + case layers::ScrollDirection::eVertical: + if (checkIfScrollableY) { + continue; + } + break; + } + } + + layers::ScrollDirections directions = + scrollableFrame->GetAvailableScrollingDirectionsForUserInputEvents(); + if ((!(directions.contains(layers::ScrollDirection::eVertical)) && + !(directions.contains(layers::ScrollDirection::eHorizontal))) || + (checkIfScrollableY && !checkIfScrollableX && + !(directions.contains(layers::ScrollDirection::eVertical))) || + (checkIfScrollableX && !checkIfScrollableY && + !(directions.contains(layers::ScrollDirection::eHorizontal)))) { + continue; + } + + // Computes whether the currently checked frame is scrollable by this wheel + // event. + bool canScroll = false; + if (isAutoDir) { + ESMAutoDirWheelDeltaAdjuster adjuster(*aEvent, *scrollFrame, honoursRoot); + if (adjuster.ShouldBeAdjusted()) { + adjuster.Adjust(); + canScroll = true; + } else if (WheelHandlingUtils::CanScrollOn(scrollableFrame, aDirectionX, + aDirectionY)) { + canScroll = true; + } + } else if (WheelHandlingUtils::CanScrollOn(scrollableFrame, aDirectionX, + aDirectionY)) { + canScroll = true; + } + + if (canScroll) { + return frameToScroll; + } + + // Where we are at is the block ending in a for loop. + // The current frame has been checked to be unscrollable by this wheel + // event, continue the loop to check its parent, if any. + } + + nsIFrame* newFrame = nsLayoutUtils::GetCrossDocParentFrameInProcess( + aTargetFrame->PresShell()->GetRootFrame()); + aOptions = + static_cast<ComputeScrollTargetOptions>(aOptions & ~START_FROM_PARENT); + if (!newFrame) { + return nullptr; + } + return ComputeScrollTargetAndMayAdjustWheelEvent(newFrame, aEvent, aOptions); +} + +nsSize EventStateManager::GetScrollAmount( + nsPresContext* aPresContext, WidgetWheelEvent* aEvent, + nsIScrollableFrame* aScrollableFrame) { + MOZ_ASSERT(aPresContext); + MOZ_ASSERT(aEvent); + + const bool isPage = aEvent->mDeltaMode == WheelEvent_Binding::DOM_DELTA_PAGE; + if (!aScrollableFrame) { + // If there is no scrollable frame, we should use root, see below. + aScrollableFrame = + aPresContext->PresShell()->GetRootScrollFrameAsScrollable(); + } + + if (aScrollableFrame) { + return isPage ? aScrollableFrame->GetPageScrollAmount() + : aScrollableFrame->GetLineScrollAmount(); + } + + // If there is no scrollable frame and page scrolling, use viewport size. + if (isPage) { + return aPresContext->GetVisibleArea().Size(); + } + + // Otherwise use root frame's font metrics. + // + // FIXME(emilio): Should this use the root element's style frame? The root + // frame will always have the initial font. Then again it should never matter + // for content, we should always have a root scrollable frame in html + // documents. + nsIFrame* rootFrame = aPresContext->PresShell()->GetRootFrame(); + if (!rootFrame) { + return nsSize(0, 0); + } + RefPtr<nsFontMetrics> fm = + nsLayoutUtils::GetInflatedFontMetricsForFrame(rootFrame); + NS_ENSURE_TRUE(fm, nsSize(0, 0)); + return nsSize(fm->AveCharWidth(), fm->MaxHeight()); +} + +void EventStateManager::DoScrollText(nsIScrollableFrame* aScrollableFrame, + WidgetWheelEvent* aEvent) { + MOZ_ASSERT(aScrollableFrame); + MOZ_ASSERT(aEvent); + + nsIFrame* scrollFrame = do_QueryFrame(aScrollableFrame); + MOZ_ASSERT(scrollFrame); + + AutoWeakFrame scrollFrameWeak(scrollFrame); + AutoWeakFrame eventFrameWeak(mCurrentTarget); + if (!WheelTransaction::WillHandleDefaultAction(aEvent, scrollFrameWeak, + eventFrameWeak)) { + return; + } + + // Default action's actual scroll amount should be computed from device + // pixels. + nsPresContext* pc = scrollFrame->PresContext(); + nsSize scrollAmount = GetScrollAmount(pc, aEvent, aScrollableFrame); + nsIntSize scrollAmountInDevPixels( + pc->AppUnitsToDevPixels(scrollAmount.width), + pc->AppUnitsToDevPixels(scrollAmount.height)); + nsIntPoint actualDevPixelScrollAmount = + DeltaAccumulator::GetInstance()->ComputeScrollAmountForDefaultAction( + aEvent, scrollAmountInDevPixels); + + // Don't scroll around the axis whose overflow style is hidden. + ScrollStyles overflowStyle = aScrollableFrame->GetScrollStyles(); + if (overflowStyle.mHorizontal == StyleOverflow::Hidden) { + actualDevPixelScrollAmount.x = 0; + } + if (overflowStyle.mVertical == StyleOverflow::Hidden) { + actualDevPixelScrollAmount.y = 0; + } + + ScrollSnapFlags snapFlags = ScrollSnapFlags::Disabled; + mozilla::ScrollOrigin origin = mozilla::ScrollOrigin::NotSpecified; + switch (aEvent->mDeltaMode) { + case WheelEvent_Binding::DOM_DELTA_LINE: + origin = mozilla::ScrollOrigin::MouseWheel; + snapFlags = ScrollSnapFlags::IntendedDirection; + break; + case WheelEvent_Binding::DOM_DELTA_PAGE: + origin = mozilla::ScrollOrigin::Pages; + snapFlags = ScrollSnapFlags::IntendedDirection | + ScrollSnapFlags::IntendedEndPosition; + break; + case WheelEvent_Binding::DOM_DELTA_PIXEL: + origin = mozilla::ScrollOrigin::Pixels; + break; + default: + MOZ_CRASH("Invalid deltaMode value comes"); + } + + // We shouldn't scroll more one page at once except when over one page scroll + // is allowed for the event. + nsSize pageSize = aScrollableFrame->GetPageScrollAmount(); + nsIntSize devPixelPageSize(pc->AppUnitsToDevPixels(pageSize.width), + pc->AppUnitsToDevPixels(pageSize.height)); + if (!WheelPrefs::GetInstance()->IsOverOnePageScrollAllowedX(aEvent) && + DeprecatedAbs(actualDevPixelScrollAmount.x.value) > + devPixelPageSize.width) { + actualDevPixelScrollAmount.x = (actualDevPixelScrollAmount.x >= 0) + ? devPixelPageSize.width + : -devPixelPageSize.width; + } + + if (!WheelPrefs::GetInstance()->IsOverOnePageScrollAllowedY(aEvent) && + DeprecatedAbs(actualDevPixelScrollAmount.y.value) > + devPixelPageSize.height) { + actualDevPixelScrollAmount.y = (actualDevPixelScrollAmount.y >= 0) + ? devPixelPageSize.height + : -devPixelPageSize.height; + } + + bool isDeltaModePixel = + (aEvent->mDeltaMode == WheelEvent_Binding::DOM_DELTA_PIXEL); + + ScrollMode mode; + switch (aEvent->mScrollType) { + case WidgetWheelEvent::SCROLL_DEFAULT: + if (isDeltaModePixel) { + mode = ScrollMode::Normal; + } else if (aEvent->mFlags.mHandledByAPZ) { + mode = ScrollMode::SmoothMsd; + } else { + mode = ScrollMode::Smooth; + } + break; + case WidgetWheelEvent::SCROLL_SYNCHRONOUSLY: + mode = ScrollMode::Instant; + break; + case WidgetWheelEvent::SCROLL_ASYNCHRONOUSLY: + mode = ScrollMode::Normal; + break; + case WidgetWheelEvent::SCROLL_SMOOTHLY: + mode = ScrollMode::Smooth; + break; + default: + MOZ_CRASH("Invalid mScrollType value comes"); + } + + nsIScrollableFrame::ScrollMomentum momentum = + aEvent->mIsMomentum ? nsIScrollableFrame::SYNTHESIZED_MOMENTUM_EVENT + : nsIScrollableFrame::NOT_MOMENTUM; + + nsIntPoint overflow; + aScrollableFrame->ScrollBy(actualDevPixelScrollAmount, + ScrollUnit::DEVICE_PIXELS, mode, &overflow, origin, + momentum, snapFlags); + + if (!scrollFrameWeak.IsAlive()) { + // If the scroll causes changing the layout, we can think that the event + // has been completely consumed by the content. Then, users probably don't + // want additional action. + aEvent->mOverflowDeltaX = aEvent->mOverflowDeltaY = 0; + } else if (isDeltaModePixel) { + aEvent->mOverflowDeltaX = overflow.x; + aEvent->mOverflowDeltaY = overflow.y; + } else { + aEvent->mOverflowDeltaX = + static_cast<double>(overflow.x) / scrollAmountInDevPixels.width; + aEvent->mOverflowDeltaY = + static_cast<double>(overflow.y) / scrollAmountInDevPixels.height; + } + + // If CSS overflow properties caused not to scroll, the overflowDelta* values + // should be same as delta* values since they may be used as gesture event by + // widget. However, if there is another scrollable element in the ancestor + // along the axis, probably users don't want the operation to cause + // additional action such as moving history. In such case, overflowDelta + // values should stay zero. + if (scrollFrameWeak.IsAlive()) { + if (aEvent->mDeltaX && overflowStyle.mHorizontal == StyleOverflow::Hidden && + !ComputeScrollTargetAndMayAdjustWheelEvent( + scrollFrame, aEvent, + COMPUTE_SCROLLABLE_ANCESTOR_ALONG_X_AXIS_WITH_AUTO_DIR)) { + aEvent->mOverflowDeltaX = aEvent->mDeltaX; + } + if (aEvent->mDeltaY && overflowStyle.mVertical == StyleOverflow::Hidden && + !ComputeScrollTargetAndMayAdjustWheelEvent( + scrollFrame, aEvent, + COMPUTE_SCROLLABLE_ANCESTOR_ALONG_Y_AXIS_WITH_AUTO_DIR)) { + aEvent->mOverflowDeltaY = aEvent->mDeltaY; + } + } + + NS_ASSERTION( + aEvent->mOverflowDeltaX == 0 || + (aEvent->mOverflowDeltaX > 0) == (aEvent->mDeltaX > 0), + "The sign of mOverflowDeltaX is different from the scroll direction"); + NS_ASSERTION( + aEvent->mOverflowDeltaY == 0 || + (aEvent->mOverflowDeltaY > 0) == (aEvent->mDeltaY > 0), + "The sign of mOverflowDeltaY is different from the scroll direction"); + + WheelPrefs::GetInstance()->CancelApplyingUserPrefsFromOverflowDelta(aEvent); +} + +void EventStateManager::DecideGestureEvent(WidgetGestureNotifyEvent* aEvent, + nsIFrame* targetFrame) { + NS_ASSERTION(aEvent->mMessage == eGestureNotify, + "DecideGestureEvent called with a non-gesture event"); + + /* Check the ancestor tree to decide if any frame is willing* to receive + * a MozPixelScroll event. If that's the case, the current touch gesture + * will be used as a pan gesture; otherwise it will be a regular + * mousedown/mousemove/click event. + * + * *willing: determine if it makes sense to pan the element using scroll + * events: + * - For web content: if there are any visible scrollbars on the touch point + * - For XUL: if it's an scrollable element that can currently scroll in some + * direction. + * + * Note: we'll have to one-off various cases to ensure a good usable behavior + */ + WidgetGestureNotifyEvent::PanDirection panDirection = + WidgetGestureNotifyEvent::ePanNone; + bool displayPanFeedback = false; + for (nsIFrame* current = targetFrame; current; + current = nsLayoutUtils::GetCrossDocParentFrame(current)) { + // e10s - mark remote content as pannable. This is a work around since + // we don't have access to remote frame scroll info here. Apz data may + // assist is solving this. + if (current && IsTopLevelRemoteTarget(current->GetContent())) { + panDirection = WidgetGestureNotifyEvent::ePanBoth; + // We don't know when we reach bounds, so just disable feedback for now. + displayPanFeedback = false; + break; + } + + LayoutFrameType currentFrameType = current->Type(); + + // Scrollbars should always be draggable + if (currentFrameType == LayoutFrameType::Scrollbar) { + panDirection = WidgetGestureNotifyEvent::ePanNone; + break; + } + + // Special check for trees + if (nsTreeBodyFrame* treeFrame = do_QueryFrame(current)) { + if (treeFrame->GetHorizontalOverflow()) { + panDirection = WidgetGestureNotifyEvent::ePanHorizontal; + } + if (treeFrame->GetVerticalOverflow()) { + panDirection = WidgetGestureNotifyEvent::ePanVertical; + } + break; + } + + if (nsIScrollableFrame* scrollableFrame = do_QueryFrame(current)) { + layers::ScrollDirections scrollbarVisibility = + scrollableFrame->GetScrollbarVisibility(); + + // Check if we have visible scrollbars + if (scrollbarVisibility.contains(layers::ScrollDirection::eVertical)) { + panDirection = WidgetGestureNotifyEvent::ePanVertical; + displayPanFeedback = true; + break; + } + + if (scrollbarVisibility.contains(layers::ScrollDirection::eHorizontal)) { + panDirection = WidgetGestureNotifyEvent::ePanHorizontal; + displayPanFeedback = true; + } + } // scrollableFrame + } // ancestor chain + aEvent->mDisplayPanFeedback = displayPanFeedback; + aEvent->mPanDirection = panDirection; +} + +#ifdef XP_MACOSX +static nsINode* GetCrossDocParentNode(nsINode* aChild) { + MOZ_ASSERT(aChild, "The child is null!"); + MOZ_ASSERT(XRE_IsParentProcess()); + + nsINode* parent = aChild->GetParentNode(); + if (parent && parent->IsContent() && aChild->IsContent()) { + parent = aChild->AsContent()->GetFlattenedTreeParent(); + } + + if (parent || !aChild->IsDocument()) { + return parent; + } + + return aChild->AsDocument()->GetEmbedderElement(); +} + +static bool NodeAllowsClickThrough(nsINode* aNode) { + while (aNode) { + if (aNode->IsAnyOfXULElements(nsGkAtoms::browser, nsGkAtoms::tree)) { + return false; + } + if (aNode->IsAnyOfXULElements(nsGkAtoms::scrollbar, nsGkAtoms::resizer)) { + return true; + } + aNode = GetCrossDocParentNode(aNode); + } + return true; +} +#endif + +void EventStateManager::PostHandleKeyboardEvent( + WidgetKeyboardEvent* aKeyboardEvent, nsIFrame* aTargetFrame, + nsEventStatus& aStatus) { + if (aStatus == nsEventStatus_eConsumeNoDefault) { + return; + } + + RefPtr<nsPresContext> presContext = mPresContext; + + if (!aKeyboardEvent->HasBeenPostedToRemoteProcess()) { + if (aKeyboardEvent->IsWaitingReplyFromRemoteProcess()) { + RefPtr<BrowserParent> remote = + aTargetFrame ? BrowserParent::GetFrom(aTargetFrame->GetContent()) + : nullptr; + if (remote) { + // remote is null-checked above in order to let pre-existing event + // targeting code's chrome vs. content decision override in case of + // disagreement in order not to disrupt non-Fission e10s mode in case + // there are still bugs in the Fission-mode code. That is, if remote + // is nullptr, the pre-existing event targeting code has deemed this + // event to belong to chrome rather than content. + BrowserParent* preciseRemote = BrowserParent::GetFocused(); + if (preciseRemote) { + remote = preciseRemote; + } + // else there was a race between layout and focus tracking + } + if (remote && !remote->IsReadyToHandleInputEvents()) { + // We need to dispatch the event to the browser element again if we were + // waiting for the key reply but the event wasn't sent to the content + // process due to the remote browser wasn't ready. + WidgetKeyboardEvent keyEvent(*aKeyboardEvent); + aKeyboardEvent->MarkAsHandledInRemoteProcess(); + RefPtr<Element> ownerElement = remote->GetOwnerElement(); + EventDispatcher::Dispatch(ownerElement, presContext, &keyEvent); + if (keyEvent.DefaultPrevented()) { + aKeyboardEvent->PreventDefault(!keyEvent.DefaultPreventedByContent()); + aStatus = nsEventStatus_eConsumeNoDefault; + return; + } + } + } + // The widget expects a reply for every keyboard event. If the event wasn't + // dispatched to a content process (non-e10s or no content process + // running), we need to short-circuit here. Otherwise, we need to wait for + // the content process to handle the event. + if (aKeyboardEvent->mWidget) { + aKeyboardEvent->mWidget->PostHandleKeyEvent(aKeyboardEvent); + } + if (aKeyboardEvent->DefaultPrevented()) { + aStatus = nsEventStatus_eConsumeNoDefault; + return; + } + } + + // XXX Currently, our automated tests don't support mKeyNameIndex. + // Therefore, we still need to handle this with keyCode. + switch (aKeyboardEvent->mKeyCode) { + case NS_VK_TAB: + case NS_VK_F6: + // This is to prevent keyboard scrolling while alt modifier in use. + if (!aKeyboardEvent->IsAlt()) { + aStatus = nsEventStatus_eConsumeNoDefault; + + // Handling the tab event after it was sent to content is bad, + // because to the FocusManager the remote-browser looks like one + // element, so we would just move the focus to the next element + // in chrome, instead of handling it in content. + if (aKeyboardEvent->HasBeenPostedToRemoteProcess()) { + break; + } + + EnsureDocument(presContext); + nsFocusManager* fm = nsFocusManager::GetFocusManager(); + if (fm && mDocument) { + // Shift focus forward or back depending on shift key + bool isDocMove = aKeyboardEvent->IsControl() || + aKeyboardEvent->mKeyCode == NS_VK_F6; + uint32_t dir = + aKeyboardEvent->IsShift() + ? (isDocMove ? static_cast<uint32_t>( + nsIFocusManager::MOVEFOCUS_BACKWARDDOC) + : static_cast<uint32_t>( + nsIFocusManager::MOVEFOCUS_BACKWARD)) + : (isDocMove ? static_cast<uint32_t>( + nsIFocusManager::MOVEFOCUS_FORWARDDOC) + : static_cast<uint32_t>( + nsIFocusManager::MOVEFOCUS_FORWARD)); + RefPtr<Element> result; + fm->MoveFocus(mDocument->GetWindow(), nullptr, dir, + nsIFocusManager::FLAG_BYKEY, getter_AddRefs(result)); + } + } + return; + case 0: + // We handle keys with no specific keycode value below. + break; + default: + return; + } + + switch (aKeyboardEvent->mKeyNameIndex) { + case KEY_NAME_INDEX_ZoomIn: + case KEY_NAME_INDEX_ZoomOut: + ChangeZoom(aKeyboardEvent->mKeyNameIndex == KEY_NAME_INDEX_ZoomIn); + aStatus = nsEventStatus_eConsumeNoDefault; + break; + default: + break; + } +} + +nsresult EventStateManager::PostHandleEvent(nsPresContext* aPresContext, + WidgetEvent* aEvent, + nsIFrame* aTargetFrame, + nsEventStatus* aStatus, + nsIContent* aOverrideClickTarget) { + NS_ENSURE_ARG(aPresContext); + NS_ENSURE_ARG_POINTER(aStatus); + + mCurrentTarget = aTargetFrame; + mCurrentTargetContent = nullptr; + + HandleCrossProcessEvent(aEvent, aStatus); + // NOTE: the above call may have destroyed aTargetFrame, please use + // mCurrentTarget henceforth. This is to avoid using it accidentally: + aTargetFrame = nullptr; + + // Most of the events we handle below require a frame. + // Add special cases here. + if (!mCurrentTarget && aEvent->mMessage != eMouseUp && + aEvent->mMessage != eMouseDown && aEvent->mMessage != eDragEnter && + aEvent->mMessage != eDragOver && aEvent->mMessage != ePointerUp && + aEvent->mMessage != ePointerCancel) { + return NS_OK; + } + + // Keep the prescontext alive, we might need it after event dispatch + RefPtr<nsPresContext> presContext = aPresContext; + nsresult ret = NS_OK; + + switch (aEvent->mMessage) { + case eMouseDown: { + WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent(); + if (mouseEvent->mButton == MouseButton::ePrimary && + !sNormalLMouseEventInProcess) { + // We got a mouseup event while a mousedown event was being processed. + // Make sure that the capturing content is cleared. + PresShell::ReleaseCapturingContent(); + break; + } + + // For remote content, capture the event in the parent process at the + // <xul:browser remote> element. This will ensure that subsequent + // mousemove/mouseup events will continue to be dispatched to this element + // and therefore forwarded to the child. + if (aEvent->HasBeenPostedToRemoteProcess() && + !PresShell::GetCapturingContent()) { + if (nsIContent* content = + mCurrentTarget ? mCurrentTarget->GetContent() : nullptr) { + PresShell::SetCapturingContent(content, CaptureFlags::None, aEvent); + } else { + PresShell::ReleaseCapturingContent(); + } + } + + // If MouseEvent::PreventClickEvent() was called by chrome script, + // we need to forget the clicking content and click count for the + // following eMouseUp event. + if (mouseEvent->mClickEventPrevented) { + RefPtr<EventStateManager> esm = + ESMFromContentOrThis(aOverrideClickTarget); + switch (mouseEvent->mButton) { + case MouseButton::ePrimary: + case MouseButton::eSecondary: + case MouseButton::eMiddle: { + LastMouseDownInfo& mouseDownInfo = + GetLastMouseDownInfo(mouseEvent->mButton); + mouseDownInfo.mLastMouseDownContent = nullptr; + mouseDownInfo.mClickCount = 0; + mouseDownInfo.mLastMouseDownInputControlType = Nothing(); + break; + } + + default: + break; + } + } + + nsCOMPtr<nsIContent> activeContent; + // When content calls PreventDefault on pointerdown, we also call + // PreventDefault on the subsequent mouse events to suppress default + // behaviors. Normally, aStatus should be nsEventStatus_eConsumeNoDefault + // when the event is DefaultPrevented but it's reset to + // nsEventStatus_eIgnore in EventStateManager::PreHandleEvent. So we also + // check if the event is DefaultPrevented. + if (nsEventStatus_eConsumeNoDefault != *aStatus && + !aEvent->DefaultPrevented()) { + nsCOMPtr<nsIContent> newFocus; + bool suppressBlur = false; + if (mCurrentTarget) { + mCurrentTarget->GetContentForEvent(aEvent, getter_AddRefs(newFocus)); + activeContent = mCurrentTarget->GetContent(); + + // In some cases, we do not want to even blur the current focused + // element. Those cases are: + // 1. -moz-user-focus CSS property is set to 'ignore'; + // 2. XUL control element has the disabled property set to 'true'. + // + // We can't use nsIFrame::IsFocusable() because we want to blur when + // we click on a visibility: none element. + // We can't use nsIContent::IsFocusable() because we want to blur when + // we click on a non-focusable element like a <div>. + // We have to use |aEvent->mTarget| to not make sure we do not check + // an anonymous node of the targeted element. + suppressBlur = + mCurrentTarget->StyleUI()->UserFocus() == StyleUserFocus::Ignore; + + if (!suppressBlur) { + if (Element* element = + Element::FromEventTargetOrNull(aEvent->mTarget)) { + if (nsCOMPtr<nsIDOMXULControlElement> xulControl = + element->AsXULControl()) { + bool disabled = false; + xulControl->GetDisabled(&disabled); + suppressBlur = disabled; + } + } + } + } + + // When a root content which isn't editable but has an editable HTML + // <body> element is clicked, we should redirect the focus to the + // the <body> element. E.g., when an user click bottom of the editor + // where is outside of the <body> element, the <body> should be focused + // and the user can edit immediately after that. + // + // NOTE: The newFocus isn't editable that also means it's not in + // designMode. In designMode, all contents are not focusable. + if (newFocus && !newFocus->IsEditable()) { + Document* doc = newFocus->GetComposedDoc(); + if (doc && newFocus == doc->GetRootElement()) { + nsIContent* bodyContent = + nsLayoutUtils::GetEditableRootContentByContentEditable(doc); + if (bodyContent && bodyContent->GetPrimaryFrame()) { + newFocus = bodyContent; + } + } + } + + // When the mouse is pressed, the default action is to focus the + // target. Look for the nearest enclosing focusable frame. + // + // TODO: Probably this should be moved to Element::PostHandleEvent. + for (; newFocus; newFocus = newFocus->GetFlattenedTreeParent()) { + if (!newFocus->IsElement()) { + continue; + } + + nsIFrame* frame = newFocus->GetPrimaryFrame(); + if (!frame) { + continue; + } + + // If the mousedown happened inside a popup, don't try to set focus on + // one of its containing elements + if (frame->IsMenuPopupFrame()) { + newFocus = nullptr; + break; + } + + if (frame->IsFocusable(/* aWithMouse = */ true)) { + break; + } + + if (ShadowRoot* root = newFocus->GetShadowRoot()) { + if (root->DelegatesFocus()) { + if (Element* firstFocusable = + root->GetFocusDelegate(/* aWithMouse */ true)) { + newFocus = firstFocusable; + break; + } + } + } + } + + MOZ_ASSERT_IF(newFocus, newFocus->IsElement()); + + if (RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager()) { + // if something was found to focus, focus it. Otherwise, if the + // element that was clicked doesn't have -moz-user-focus: ignore, + // clear the existing focus. For -moz-user-focus: ignore, the focus + // is just left as is. + // Another effect of mouse clicking, handled in Selection, is that + // it should update the caret position to where the mouse was + // clicked. Because the focus is cleared when clicking on a + // non-focusable node, the next press of the tab key will cause + // focus to be shifted from the caret position instead of the root. + if (newFocus) { + // use the mouse flag and the noscroll flag so that the content + // doesn't unexpectedly scroll when clicking an element that is + // only half visible + uint32_t flags = + nsIFocusManager::FLAG_BYMOUSE | nsIFocusManager::FLAG_NOSCROLL; + // If this was a touch-generated event, pass that information: + if (mouseEvent->mInputSource == + MouseEvent_Binding::MOZ_SOURCE_TOUCH) { + flags |= nsIFocusManager::FLAG_BYTOUCH; + } + fm->SetFocus(MOZ_KnownLive(newFocus->AsElement()), flags); + } else if (!suppressBlur) { + // clear the focus within the frame and then set it as the + // focused frame + EnsureDocument(mPresContext); + if (mDocument) { + nsCOMPtr<nsPIDOMWindowOuter> outerWindow = mDocument->GetWindow(); +#ifdef XP_MACOSX + if (!activeContent || !activeContent->IsXULElement()) +#endif + fm->ClearFocus(outerWindow); + // Prevent switch frame if we're already not in the foreground tab + // and we're in a content process. + // TODO: If we were inactive frame in this tab, and now in + // background tab, we shouldn't make the tab foreground, but + // we should set focus to clicked document in the background + // tab. However, nsFocusManager does not have proper method + // for doing this. Therefore, we should skip setting focus + // to clicked document for now. + if (XRE_IsParentProcess() || IsInActiveTab(mDocument)) { + fm->SetFocusedWindow(outerWindow); + } + } + } + } + + // The rest is left button-specific. + if (mouseEvent->mButton != MouseButton::ePrimary) { + break; + } + + // The nearest enclosing element goes into the :active state. If we're + // not an element (so we're text or something) we need to obtain + // our parent element and put it into :active instead. + if (activeContent && !activeContent->IsElement()) { + if (nsIContent* par = activeContent->GetFlattenedTreeParent()) { + activeContent = par; + } + } + } else { + // if we're here, the event handler returned false, so stop + // any of our own processing of a drag. Workaround for bug 43258. + StopTrackingDragGesture(true); + } + // XXX Why do we always set this is active? Active window may be changed + // by a mousedown event listener. + SetActiveManager(this, activeContent); + } break; + case ePointerCancel: + case ePointerUp: { + WidgetPointerEvent* pointerEvent = aEvent->AsPointerEvent(); + MOZ_ASSERT(pointerEvent); + // Implicitly releasing capture for given pointer. ePointerLostCapture + // should be send after ePointerUp or ePointerCancel. + PointerEventHandler::ImplicitlyReleasePointerCapture(pointerEvent); + PointerEventHandler::UpdateActivePointerState(pointerEvent); + + if (pointerEvent->mMessage == ePointerCancel || + pointerEvent->mInputSource == MouseEvent_Binding::MOZ_SOURCE_TOUCH) { + // After pointercancel, pointer becomes invalid so we can remove + // relevant helper from table. Regarding pointerup with non-hoverable + // device, the pointer also becomes invalid. Hoverable (mouse/pen) + // pointers are valid all the time (not only between down/up). + GenerateMouseEnterExit(pointerEvent); + mPointersEnterLeaveHelper.Remove(pointerEvent->pointerId); + } + break; + } + case eMouseUp: { + // We can unconditionally stop capturing because + // we should never be capturing when the mouse button is up + PresShell::ReleaseCapturingContent(); + + WidgetMouseEvent* mouseUpEvent = aEvent->AsMouseEvent(); + // If the mouseup event is a synthesized mouse event due to a touch, do + // not clear the activation state. Element activation is handled by APZ. + if (!mouseUpEvent || mouseUpEvent->mInputSource != + dom::MouseEvent_Binding::MOZ_SOURCE_TOUCH) { + ClearGlobalActiveContent(this); + } + if (mouseUpEvent && EventCausesClickEvents(*mouseUpEvent)) { + // Make sure to dispatch the click even if there is no frame for + // the current target element. This is required for Web compatibility. + RefPtr<EventStateManager> esm = + ESMFromContentOrThis(aOverrideClickTarget); + ret = + esm->PostHandleMouseUp(mouseUpEvent, aStatus, aOverrideClickTarget); + } + + if (PresShell* presShell = presContext->GetPresShell()) { + RefPtr<nsFrameSelection> frameSelection = presShell->FrameSelection(); + frameSelection->SetDragState(false); + } + } break; + case eWheelOperationEnd: { + MOZ_ASSERT(aEvent->IsTrusted()); + ScrollbarsForWheel::MayInactivate(); + WidgetWheelEvent* wheelEvent = aEvent->AsWheelEvent(); + nsIScrollableFrame* scrollTarget = + do_QueryFrame(ComputeScrollTargetAndMayAdjustWheelEvent( + mCurrentTarget, wheelEvent, + COMPUTE_DEFAULT_ACTION_TARGET_WITH_AUTO_DIR)); + // If the wheel event was handled by APZ, APZ will perform the scroll + // snap. + if (scrollTarget && !WheelTransaction::HandledByApz()) { + scrollTarget->ScrollSnap(); + } + } break; + case eWheel: + case eWheelOperationStart: { + MOZ_ASSERT(aEvent->IsTrusted()); + + if (*aStatus == nsEventStatus_eConsumeNoDefault) { + ScrollbarsForWheel::Inactivate(); + break; + } + + WidgetWheelEvent* wheelEvent = aEvent->AsWheelEvent(); + MOZ_ASSERT(wheelEvent); + + // When APZ is enabled, the actual scroll animation might be handled by + // the compositor. + WheelPrefs::Action action = + wheelEvent->mFlags.mHandledByAPZ + ? WheelPrefs::ACTION_NONE + : WheelPrefs::GetInstance()->ComputeActionFor(wheelEvent); + + WheelDeltaAdjustmentStrategy strategy = + GetWheelDeltaAdjustmentStrategy(*wheelEvent); + // Adjust the delta values of the wheel event if the current default + // action is to horizontalize scrolling. I.e., deltaY values are set to + // deltaX and deltaY and deltaZ values are set to 0. + // If horizontalized, the delta values will be restored and its overflow + // deltaX will become 0 when the WheelDeltaHorizontalizer instance is + // being destroyed. + WheelDeltaHorizontalizer horizontalizer(*wheelEvent); + if (WheelDeltaAdjustmentStrategy::eHorizontalize == strategy) { + horizontalizer.Horizontalize(); + } + + // Since ComputeScrollTargetAndMayAdjustWheelEvent() may adjust the delta + // if the event is auto-dir. So we use |ESMAutoDirWheelDeltaRestorer| + // here. + // An instance of |ESMAutoDirWheelDeltaRestorer| is used to monitor + // auto-dir adjustment which may happen during its lifetime. If the delta + // values is adjusted during its lifetime, the instance will restore the + // adjusted delta when it's being destrcuted. + ESMAutoDirWheelDeltaRestorer restorer(*wheelEvent); + nsIFrame* frameToScroll = ComputeScrollTargetAndMayAdjustWheelEvent( + mCurrentTarget, wheelEvent, + COMPUTE_DEFAULT_ACTION_TARGET_WITH_AUTO_DIR); + + switch (action) { + case WheelPrefs::ACTION_SCROLL: + case WheelPrefs::ACTION_HORIZONTALIZED_SCROLL: { + // For scrolling of default action, we should honor the mouse wheel + // transaction. + + ScrollbarsForWheel::PrepareToScrollText(this, mCurrentTarget, + wheelEvent); + + if (aEvent->mMessage != eWheel || + (!wheelEvent->mDeltaX && !wheelEvent->mDeltaY)) { + break; + } + + nsIScrollableFrame* scrollTarget = do_QueryFrame(frameToScroll); + ScrollbarsForWheel::SetActiveScrollTarget(scrollTarget); + + nsIFrame* rootScrollFrame = + !mCurrentTarget + ? nullptr + : mCurrentTarget->PresShell()->GetRootScrollFrame(); + nsIScrollableFrame* rootScrollableFrame = nullptr; + if (rootScrollFrame) { + rootScrollableFrame = do_QueryFrame(rootScrollFrame); + } + if (!scrollTarget || scrollTarget == rootScrollableFrame) { + wheelEvent->mViewPortIsOverscrolled = true; + } + wheelEvent->mOverflowDeltaX = wheelEvent->mDeltaX; + wheelEvent->mOverflowDeltaY = wheelEvent->mDeltaY; + WheelPrefs::GetInstance()->CancelApplyingUserPrefsFromOverflowDelta( + wheelEvent); + if (scrollTarget) { + DoScrollText(scrollTarget, wheelEvent); + } else { + WheelTransaction::EndTransaction(); + ScrollbarsForWheel::Inactivate(); + } + break; + } + case WheelPrefs::ACTION_HISTORY: { + // If this event doesn't cause eLegacyMouseLineOrPageScroll event or + // the direction is oblique, don't perform history back/forward. + int32_t intDelta = wheelEvent->GetPreferredIntDelta(); + if (!intDelta) { + break; + } + DoScrollHistory(intDelta); + break; + } + case WheelPrefs::ACTION_ZOOM: { + // If this event doesn't cause eLegacyMouseLineOrPageScroll event or + // the direction is oblique, don't perform zoom in/out. + int32_t intDelta = wheelEvent->GetPreferredIntDelta(); + if (!intDelta) { + break; + } + DoScrollZoom(mCurrentTarget, intDelta); + break; + } + case WheelPrefs::ACTION_NONE: + default: + bool allDeltaOverflown = false; + if (StaticPrefs::dom_event_wheel_event_groups_enabled() && + (wheelEvent->mDeltaX != 0.0 || wheelEvent->mDeltaY != 0.0)) { + if (frameToScroll) { + WheelTransaction::WillHandleDefaultAction( + wheelEvent, frameToScroll, mCurrentTarget); + } else { + WheelTransaction::EndTransaction(); + } + } + if (wheelEvent->mFlags.mHandledByAPZ) { + if (wheelEvent->mCanTriggerSwipe) { + // For events that can trigger swipes, APZ needs to know whether + // scrolling is possible in the requested direction. It does this + // by looking at the scroll overflow values on mCanTriggerSwipe + // events after they have been processed. + allDeltaOverflown = !ComputeScrollTarget( + mCurrentTarget, wheelEvent, COMPUTE_DEFAULT_ACTION_TARGET); + } + } else { + // The event was processed neither by APZ nor by us, so all of the + // delta values must be overflown delta values. + allDeltaOverflown = true; + } + + if (!allDeltaOverflown) { + break; + } + wheelEvent->mOverflowDeltaX = wheelEvent->mDeltaX; + wheelEvent->mOverflowDeltaY = wheelEvent->mDeltaY; + WheelPrefs::GetInstance()->CancelApplyingUserPrefsFromOverflowDelta( + wheelEvent); + wheelEvent->mViewPortIsOverscrolled = true; + break; + } + *aStatus = nsEventStatus_eConsumeNoDefault; + } break; + + case eGestureNotify: { + if (nsEventStatus_eConsumeNoDefault != *aStatus) { + DecideGestureEvent(aEvent->AsGestureNotifyEvent(), mCurrentTarget); + } + } break; + + case eDragEnter: + case eDragOver: { + NS_ASSERTION(aEvent->mClass == eDragEventClass, "Expected a drag event"); + + // Check if the drag is occurring inside a scrollable area. If so, scroll + // the area when the mouse is near the edges. + if (mCurrentTarget && aEvent->mMessage == eDragOver) { + nsIFrame* checkFrame = mCurrentTarget; + while (checkFrame) { + nsIScrollableFrame* scrollFrame = do_QueryFrame(checkFrame); + // Break out so only the innermost scrollframe is scrolled. + if (scrollFrame && scrollFrame->DragScroll(aEvent)) { + break; + } + checkFrame = checkFrame->GetParent(); + } + } + + nsCOMPtr<nsIDragSession> dragSession = nsContentUtils::GetDragSession(); + if (!dragSession) break; + + // Reset the flag. + dragSession->SetOnlyChromeDrop(false); + if (mPresContext) { + EnsureDocument(mPresContext); + } + bool isChromeDoc = nsContentUtils::IsChromeDoc(mDocument); + + // the initial dataTransfer is the one from the dragstart event that + // was set on the dragSession when the drag began. + RefPtr<DataTransfer> dataTransfer; + RefPtr<DataTransfer> initialDataTransfer = dragSession->GetDataTransfer(); + + WidgetDragEvent* dragEvent = aEvent->AsDragEvent(); + + // collect any changes to moz cursor settings stored in the event's + // data transfer. + UpdateDragDataTransfer(dragEvent); + + // cancelling a dragenter or dragover event means that a drop should be + // allowed, so update the dropEffect and the canDrop state to indicate + // that a drag is allowed. If the event isn't cancelled, a drop won't be + // allowed. Essentially, to allow a drop somewhere, specify the effects + // using the effectAllowed and dropEffect properties in a dragenter or + // dragover event and cancel the event. To not allow a drop somewhere, + // don't cancel the event or set the effectAllowed or dropEffect to + // "none". This way, if the event is just ignored, no drop will be + // allowed. + uint32_t dropEffect = nsIDragService::DRAGDROP_ACTION_NONE; + uint32_t action = nsIDragService::DRAGDROP_ACTION_NONE; + if (nsEventStatus_eConsumeNoDefault == *aStatus) { + // If the event has initialized its mDataTransfer, use it. + // Or the event has not been initialized its mDataTransfer, but + // it's set before dispatch because of synthesized, but without + // testing session (e.g., emulating drag from another app), use it + // coming from outside. + // XXX Perhaps, for the latter case, we need new API because we don't + // have a chance to initialize allowed effects of the session. + if (dragEvent->mDataTransfer) { + // get the dataTransfer and the dropEffect that was set on it + dataTransfer = dragEvent->mDataTransfer; + dropEffect = dataTransfer->DropEffectInt(); + } else { + // if dragEvent->mDataTransfer is null, it means that no attempt was + // made to access the dataTransfer during the event, yet the event + // was cancelled. Instead, use the initial data transfer available + // from the drag session. The drop effect would not have been + // initialized (which is done in DragEvent::GetDataTransfer), + // so set it from the drag action. We'll still want to filter it + // based on the effectAllowed below. + dataTransfer = initialDataTransfer; + + dragSession->GetDragAction(&action); + + // filter the drop effect based on the action. Use UNINITIALIZED as + // any effect is allowed. + dropEffect = nsContentUtils::FilterDropEffect( + action, nsIDragService::DRAGDROP_ACTION_UNINITIALIZED); + } + + // At this point, if the dataTransfer is null, it means that the + // drag was originally started by directly calling the drag service. + // Just assume that all effects are allowed. + uint32_t effectAllowed = nsIDragService::DRAGDROP_ACTION_UNINITIALIZED; + if (dataTransfer) { + effectAllowed = dataTransfer->EffectAllowedInt(); + } + + // set the drag action based on the drop effect and effect allowed. + // The drop effect field on the drag transfer object specifies the + // desired current drop effect. However, it cannot be used if the + // effectAllowed state doesn't include that type of action. If the + // dropEffect is "none", then the action will be 'none' so a drop will + // not be allowed. + if (effectAllowed == nsIDragService::DRAGDROP_ACTION_UNINITIALIZED || + dropEffect & effectAllowed) + action = dropEffect; + + if (action == nsIDragService::DRAGDROP_ACTION_NONE) + dropEffect = nsIDragService::DRAGDROP_ACTION_NONE; + + // inform the drag session that a drop is allowed on this node. + dragSession->SetDragAction(action); + dragSession->SetCanDrop(action != nsIDragService::DRAGDROP_ACTION_NONE); + + // For now, do this only for dragover. + // XXXsmaug dragenter needs some more work. + if (aEvent->mMessage == eDragOver && !isChromeDoc) { + // Someone has called preventDefault(), check whether is was on + // content or chrome. + dragSession->SetOnlyChromeDrop( + !dragEvent->mDefaultPreventedOnContent); + } + } else if (aEvent->mMessage == eDragOver && !isChromeDoc) { + // No one called preventDefault(), so handle drop only in chrome. + dragSession->SetOnlyChromeDrop(true); + } + if (ContentChild* child = ContentChild::GetSingleton()) { + child->SendUpdateDropEffect(action, dropEffect); + } + if (aEvent->HasBeenPostedToRemoteProcess()) { + dragSession->SetCanDrop(true); + } else if (initialDataTransfer) { + // Now set the drop effect in the initial dataTransfer. This ensures + // that we can get the desired drop effect in the drop event. For events + // dispatched to content, the content process will take care of setting + // this. + initialDataTransfer->SetDropEffectInt(dropEffect); + } + } break; + + case eDrop: { + if (aEvent->mFlags.mIsSynthesizedForTests) { + if (nsCOMPtr<nsIDragSession> dragSession = + nsContentUtils::GetDragSession()) { + MOZ_ASSERT(dragSession->IsSynthesizedForTests()); + RefPtr<WindowContext> sourceWC; + DebugOnly<nsresult> rvIgnored = + dragSession->GetSourceWindowContext(getter_AddRefs(sourceWC)); + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rvIgnored), + "nsIDragSession::GetSourceDocument() failed, but ignored"); + // If the drag source hasn't been initialized, i.e., dragstart was + // consumed by the test, the test needs to dispatch "dragend" event + // instead of the drag session. Therefore, it does not make sense + // to set drag end point in such case (you hit assersion if you do + // it). + if (sourceWC) { + CSSIntPoint dropPointInScreen = + Event::GetScreenCoords(aPresContext, aEvent, aEvent->mRefPoint) + .extract(); + dragSession->SetDragEndPointForTests(dropPointInScreen.x, + dropPointInScreen.y); + } + } + } + sLastDragOverFrame = nullptr; + ClearGlobalActiveContent(this); + break; + } + case eDragExit: + // make sure to fire the enter and exit_synth events after the + // eDragExit event, otherwise we'll clean up too early + GenerateDragDropEnterExit(presContext, aEvent->AsDragEvent()); + if (ContentChild* child = ContentChild::GetSingleton()) { + // SendUpdateDropEffect to prevent nsIDragService from waiting for + // response of forwarded dragexit event. + child->SendUpdateDropEffect(nsIDragService::DRAGDROP_ACTION_NONE, + nsIDragService::DRAGDROP_ACTION_NONE); + } + break; + + case eKeyUp: + // If space key is released, we need to inactivate the element which was + // activated by preceding space key down. + // XXX Currently, we don't store the reason of activation. Therefore, + // this may cancel what is activated by a mousedown, but it must not + // cause actual problem in web apps in the wild since it must be + // rare case that users release space key during a mouse click/drag. + if (aEvent->AsKeyboardEvent()->ShouldWorkAsSpaceKey()) { + ClearGlobalActiveContent(this); + } + break; + + case eKeyPress: { + WidgetKeyboardEvent* keyEvent = aEvent->AsKeyboardEvent(); + PostHandleKeyboardEvent(keyEvent, mCurrentTarget, *aStatus); + } break; + + case eMouseEnterIntoWidget: + if (mCurrentTarget) { + nsCOMPtr<nsIContent> targetContent; + mCurrentTarget->GetContentForEvent(aEvent, + getter_AddRefs(targetContent)); + SetContentState(targetContent, ElementState::HOVER); + } + break; + + case eMouseExitFromWidget: + PointerEventHandler::UpdateActivePointerState(aEvent->AsMouseEvent()); + break; + +#ifdef XP_MACOSX + case eMouseActivate: + if (mCurrentTarget) { + nsCOMPtr<nsIContent> targetContent; + mCurrentTarget->GetContentForEvent(aEvent, + getter_AddRefs(targetContent)); + if (!NodeAllowsClickThrough(targetContent)) { + *aStatus = nsEventStatus_eConsumeNoDefault; + } + } + break; +#endif + + default: + break; + } + + // Reset target frame to null to avoid mistargeting after reentrant event + mCurrentTarget = nullptr; + mCurrentTargetContent = nullptr; + + return ret; +} + +BrowserParent* EventStateManager::GetCrossProcessTarget() { + return IMEStateManager::GetActiveBrowserParent(); +} + +bool EventStateManager::IsTargetCrossProcess(WidgetGUIEvent* aEvent) { + // Check to see if there is a focused, editable content in chrome, + // in that case, do not forward IME events to content + Element* focusedElement = GetFocusedElement(); + if (focusedElement && focusedElement->IsEditable()) { + return false; + } + return IMEStateManager::GetActiveBrowserParent() != nullptr; +} + +void EventStateManager::NotifyDestroyPresContext(nsPresContext* aPresContext) { + RefPtr<nsPresContext> presContext = aPresContext; + if (presContext) { + IMEStateManager::OnDestroyPresContext(*presContext); + } + + // Bug 70855: Presentation is going away, possibly for a reframe. + // Reset the hover state so that if we're recreating the presentation, + // we won't have the old hover state still set in the new presentation, + // as if the new presentation is resized, a new element may be hovered. + ResetHoverState(); + + mPointersEnterLeaveHelper.Clear(); + PointerEventHandler::NotifyDestroyPresContext(presContext); +} + +void EventStateManager::ResetHoverState() { + if (mHoverContent) { + SetContentState(nullptr, ElementState::HOVER); + } +} + +void EventStateManager::SetPresContext(nsPresContext* aPresContext) { + mPresContext = aPresContext; +} + +void EventStateManager::ClearFrameRefs(nsIFrame* aFrame) { + if (aFrame && aFrame == mCurrentTarget) { + mCurrentTargetContent = aFrame->GetContent(); + } +} + +struct CursorImage { + gfx::IntPoint mHotspot; + nsCOMPtr<imgIContainer> mContainer; + ImageResolution mResolution; + bool mEarlierCursorLoading = false; +}; + +// Given the event that we're processing, and the computed cursor and hotspot, +// determine whether the custom CSS cursor should be blocked (that is, not +// honored). +// +// We will not honor it all of the following are true: +// +// * the size of the custom cursor is bigger than layout.cursor.block.max-size. +// * the bounds of the cursor would end up outside of the viewport of the +// top-level content document. +// +// This is done in order to prevent hijacking the cursor, see bug 1445844 and +// co. +static bool ShouldBlockCustomCursor(nsPresContext* aPresContext, + WidgetEvent* aEvent, + const CursorImage& aCursor) { + int32_t width = 0; + int32_t height = 0; + aCursor.mContainer->GetWidth(&width); + aCursor.mContainer->GetHeight(&height); + aCursor.mResolution.ApplyTo(width, height); + + int32_t maxSize = StaticPrefs::layout_cursor_block_max_size(); + + if (width <= maxSize && height <= maxSize) { + return false; + } + + auto input = DOMIntersectionObserver::ComputeInput(*aPresContext->Document(), + nullptr, nullptr); + + if (!input.mRootFrame) { + return false; + } + + nsPoint point = nsLayoutUtils::GetEventCoordinatesRelativeTo( + aEvent, RelativeTo{input.mRootFrame}); + + // The cursor size won't be affected by our full zoom in the parent process, + // so undo that before checking the rect. + float zoom = aPresContext->GetFullZoom(); + + // Also adjust for accessibility cursor scaling factor. + zoom /= LookAndFeel::GetFloat(LookAndFeel::FloatID::CursorScale, 1.0f); + + nsSize size(CSSPixel::ToAppUnits(width / zoom), + CSSPixel::ToAppUnits(height / zoom)); + nsPoint hotspot( + CSSPixel::ToAppUnits(ViewAs<CSSPixel>(aCursor.mHotspot.x / zoom)), + CSSPixel::ToAppUnits(ViewAs<CSSPixel>(aCursor.mHotspot.y / zoom))); + + const nsRect cursorRect(point - hotspot, size); + auto output = DOMIntersectionObserver::Intersect(input, cursorRect); + return !output.mIntersectionRect || + !(*output.mIntersectionRect == cursorRect); +} + +static gfx::IntPoint ComputeHotspot(imgIContainer* aContainer, + const Maybe<gfx::Point>& aHotspot) { + MOZ_ASSERT(aContainer); + + // css3-ui says to use the CSS-specified hotspot if present, + // otherwise use the intrinsic hotspot, otherwise use the top left + // corner. + if (aHotspot) { + int32_t imgWidth, imgHeight; + aContainer->GetWidth(&imgWidth); + aContainer->GetHeight(&imgHeight); + auto hotspot = gfx::IntPoint::Round(*aHotspot); + return {std::max(std::min(hotspot.x.value, imgWidth - 1), 0), + std::max(std::min(hotspot.y.value, imgHeight - 1), 0)}; + } + + gfx::IntPoint hotspot; + aContainer->GetHotspotX(&hotspot.x.value); + aContainer->GetHotspotY(&hotspot.y.value); + return hotspot; +} + +static CursorImage ComputeCustomCursor(nsPresContext* aPresContext, + WidgetEvent* aEvent, + const nsIFrame& aFrame, + const nsIFrame::Cursor& aCursor) { + if (aCursor.mAllowCustomCursor == nsIFrame::AllowCustomCursorImage::No) { + return {}; + } + const ComputedStyle& style = + aCursor.mStyle ? *aCursor.mStyle : *aFrame.Style(); + + // If we are falling back because any cursor before us is loading, let the + // consumer know. + bool loading = false; + for (const auto& image : style.StyleUI()->Cursor().images.AsSpan()) { + MOZ_ASSERT(image.image.IsImageRequestType(), + "Cursor image should only parse url() types"); + uint32_t status; + imgRequestProxy* req = image.image.GetImageRequest(); + if (!req || NS_FAILED(req->GetImageStatus(&status))) { + continue; + } + if (!(status & imgIRequest::STATUS_LOAD_COMPLETE)) { + loading = true; + continue; + } + if (status & imgIRequest::STATUS_ERROR) { + continue; + } + nsCOMPtr<imgIContainer> container; + req->GetImage(getter_AddRefs(container)); + if (!container) { + continue; + } + StyleImageOrientation orientation = + aFrame.StyleVisibility()->UsedImageOrientation(req); + container = nsLayoutUtils::OrientImage(container, orientation); + Maybe<gfx::Point> specifiedHotspot = + image.has_hotspot ? Some(gfx::Point{image.hotspot_x, image.hotspot_y}) + : Nothing(); + gfx::IntPoint hotspot = ComputeHotspot(container, specifiedHotspot); + CursorImage result{hotspot, std::move(container), + image.image.GetResolution(style), loading}; + if (ShouldBlockCustomCursor(aPresContext, aEvent, result)) { + continue; + } + // This is the one we want! + return result; + } + return {{}, nullptr, {}, loading}; +} + +void EventStateManager::UpdateCursor(nsPresContext* aPresContext, + WidgetMouseEvent* aEvent, + nsIFrame* aTargetFrame, + nsEventStatus* aStatus) { + if (aTargetFrame && IsRemoteTarget(aTargetFrame->GetContent())) { + return; + } + + auto cursor = StyleCursorKind::Default; + nsCOMPtr<imgIContainer> container; + ImageResolution resolution; + Maybe<gfx::IntPoint> hotspot; + + if (mHidingCursorWhileTyping && aEvent->IsReal()) { + // Any non-synthetic mouse event makes us show the cursor again. + mHidingCursorWhileTyping = false; + } + + if (mHidingCursorWhileTyping) { + cursor = StyleCursorKind::None; + } else if (mLockCursor != kInvalidCursorKind) { + // If cursor is locked just use the locked one + cursor = mLockCursor; + } else if (aTargetFrame) { + // If not locked, look for correct cursor + nsPoint pt = nsLayoutUtils::GetEventCoordinatesRelativeTo( + aEvent, RelativeTo{aTargetFrame}); + const nsIFrame::Cursor framecursor = aTargetFrame->GetCursor(pt); + const CursorImage customCursor = + ComputeCustomCursor(aPresContext, aEvent, *aTargetFrame, framecursor); + + // If the current cursor is from the same frame, and it is now + // loading some new image for the cursor, we should wait for a + // while rather than taking its fallback cursor directly. + if (customCursor.mEarlierCursorLoading && + gLastCursorSourceFrame == aTargetFrame && + TimeStamp::NowLoRes() - gLastCursorUpdateTime < + TimeDuration::FromMilliseconds(kCursorLoadingTimeout)) { + return; + } + cursor = framecursor.mCursor; + container = std::move(customCursor.mContainer); + resolution = customCursor.mResolution; + hotspot = Some(customCursor.mHotspot); + } + + if (aTargetFrame) { + if (cursor == StyleCursorKind::Pointer && IsSelectingLink(aTargetFrame)) { + cursor = aTargetFrame->GetWritingMode().IsVertical() + ? StyleCursorKind::VerticalText + : StyleCursorKind::Text; + } + SetCursor(cursor, container, resolution, hotspot, + aTargetFrame->GetNearestWidget(), false); + gLastCursorSourceFrame = aTargetFrame; + gLastCursorUpdateTime = TimeStamp::NowLoRes(); + } + + if (mLockCursor != kInvalidCursorKind || StyleCursorKind::Auto != cursor) { + *aStatus = nsEventStatus_eConsumeDoDefault; + } +} + +void EventStateManager::ClearCachedWidgetCursor(nsIFrame* aTargetFrame) { + if (!aTargetFrame) { + return; + } + nsIWidget* aWidget = aTargetFrame->GetNearestWidget(); + if (!aWidget) { + return; + } + aWidget->ClearCachedCursor(); +} + +void EventStateManager::StartHidingCursorWhileTyping(nsIWidget* aWidget) { + if (mHidingCursorWhileTyping || sCursorSettingManager != this) { + return; + } + mHidingCursorWhileTyping = true; + SetCursor(StyleCursorKind::None, nullptr, {}, {}, aWidget, false); +} + +nsresult EventStateManager::SetCursor(StyleCursorKind aCursor, + imgIContainer* aContainer, + const ImageResolution& aResolution, + const Maybe<gfx::IntPoint>& aHotspot, + nsIWidget* aWidget, bool aLockCursor) { + EnsureDocument(mPresContext); + NS_ENSURE_TRUE(mDocument, NS_ERROR_FAILURE); + sCursorSettingManager = this; + + NS_ENSURE_TRUE(aWidget, NS_ERROR_FAILURE); + if (aLockCursor) { + if (StyleCursorKind::Auto != aCursor) { + mLockCursor = aCursor; + } else { + // If cursor style is set to auto we unlock the cursor again. + mLockCursor = kInvalidCursorKind; + } + } + nsCursor c; + switch (aCursor) { + case StyleCursorKind::Auto: + case StyleCursorKind::Default: + c = eCursor_standard; + break; + case StyleCursorKind::Pointer: + c = eCursor_hyperlink; + break; + case StyleCursorKind::Crosshair: + c = eCursor_crosshair; + break; + case StyleCursorKind::Move: + c = eCursor_move; + break; + case StyleCursorKind::Text: + c = eCursor_select; + break; + case StyleCursorKind::Wait: + c = eCursor_wait; + break; + case StyleCursorKind::Help: + c = eCursor_help; + break; + case StyleCursorKind::NResize: + c = eCursor_n_resize; + break; + case StyleCursorKind::SResize: + c = eCursor_s_resize; + break; + case StyleCursorKind::WResize: + c = eCursor_w_resize; + break; + case StyleCursorKind::EResize: + c = eCursor_e_resize; + break; + case StyleCursorKind::NwResize: + c = eCursor_nw_resize; + break; + case StyleCursorKind::SeResize: + c = eCursor_se_resize; + break; + case StyleCursorKind::NeResize: + c = eCursor_ne_resize; + break; + case StyleCursorKind::SwResize: + c = eCursor_sw_resize; + break; + case StyleCursorKind::Copy: // CSS3 + c = eCursor_copy; + break; + case StyleCursorKind::Alias: + c = eCursor_alias; + break; + case StyleCursorKind::ContextMenu: + c = eCursor_context_menu; + break; + case StyleCursorKind::Cell: + c = eCursor_cell; + break; + case StyleCursorKind::Grab: + c = eCursor_grab; + break; + case StyleCursorKind::Grabbing: + c = eCursor_grabbing; + break; + case StyleCursorKind::Progress: + c = eCursor_spinning; + break; + case StyleCursorKind::ZoomIn: + c = eCursor_zoom_in; + break; + case StyleCursorKind::ZoomOut: + c = eCursor_zoom_out; + break; + case StyleCursorKind::NotAllowed: + c = eCursor_not_allowed; + break; + case StyleCursorKind::ColResize: + c = eCursor_col_resize; + break; + case StyleCursorKind::RowResize: + c = eCursor_row_resize; + break; + case StyleCursorKind::NoDrop: + c = eCursor_no_drop; + break; + case StyleCursorKind::VerticalText: + c = eCursor_vertical_text; + break; + case StyleCursorKind::AllScroll: + c = eCursor_all_scroll; + break; + case StyleCursorKind::NeswResize: + c = eCursor_nesw_resize; + break; + case StyleCursorKind::NwseResize: + c = eCursor_nwse_resize; + break; + case StyleCursorKind::NsResize: + c = eCursor_ns_resize; + break; + case StyleCursorKind::EwResize: + c = eCursor_ew_resize; + break; + case StyleCursorKind::None: + c = eCursor_none; + break; + default: + MOZ_ASSERT_UNREACHABLE("Unknown cursor kind"); + c = eCursor_standard; + break; + } + + uint32_t x = aHotspot ? aHotspot->x.value : 0; + uint32_t y = aHotspot ? aHotspot->y.value : 0; + aWidget->SetCursor(nsIWidget::Cursor{c, aContainer, x, y, aResolution}); + return NS_OK; +} + +class MOZ_STACK_CLASS ESMEventCB : public EventDispatchingCallback { + public: + explicit ESMEventCB(nsIContent* aTarget) : mTarget(aTarget) {} + + MOZ_CAN_RUN_SCRIPT + void HandleEvent(EventChainPostVisitor& aVisitor) override { + if (aVisitor.mPresContext) { + nsIFrame* frame = aVisitor.mPresContext->GetPrimaryFrameFor(mTarget); + if (frame) { + frame->HandleEvent(aVisitor.mPresContext, aVisitor.mEvent->AsGUIEvent(), + &aVisitor.mEventStatus); + } + } + } + + nsCOMPtr<nsIContent> mTarget; +}; + +static UniquePtr<WidgetMouseEvent> CreateMouseOrPointerWidgetEvent( + WidgetMouseEvent* aMouseEvent, EventMessage aMessage, + EventTarget* aRelatedTarget) { + // This method does not support creating a mouse/pointer button change event + // because of no data about the changing state. + MOZ_ASSERT(aMessage != eMouseDown); + MOZ_ASSERT(aMessage != eMouseUp); + MOZ_ASSERT(aMessage != ePointerDown); + MOZ_ASSERT(aMessage != ePointerUp); + // This method is currently designed to create the following events. + MOZ_ASSERT(aMessage == eMouseOver || aMessage == eMouseEnter || + aMessage == eMouseOut || aMessage == eMouseLeave || + aMessage == ePointerOver || aMessage == ePointerEnter || + aMessage == ePointerOut || aMessage == ePointerLeave || + aMessage == eMouseEnterIntoWidget || + aMessage == eMouseExitFromWidget); + + WidgetPointerEvent* sourcePointer = aMouseEvent->AsPointerEvent(); + UniquePtr<WidgetMouseEvent> newEvent; + if (sourcePointer) { + AUTO_PROFILER_LABEL("CreateMouseOrPointerWidgetEvent", OTHER); + + WidgetPointerEvent* newPointerEvent = new WidgetPointerEvent( + aMouseEvent->IsTrusted(), aMessage, aMouseEvent->mWidget); + newPointerEvent->mIsPrimary = sourcePointer->mIsPrimary; + newPointerEvent->mWidth = sourcePointer->mWidth; + newPointerEvent->mHeight = sourcePointer->mHeight; + newPointerEvent->mInputSource = sourcePointer->mInputSource; + + newEvent = WrapUnique(newPointerEvent); + } else { + newEvent = MakeUnique<WidgetMouseEvent>(aMouseEvent->IsTrusted(), aMessage, + aMouseEvent->mWidget, + WidgetMouseEvent::eReal); + } + + // Inherit whether the event is synthesized by the test API or not. + // Then, when the event is synthesized by a test API and handled in a remote + // process, it won't be ignored. See PresShell::HandleEvent(). + newEvent->mFlags.mIsSynthesizedForTests = + aMouseEvent->mFlags.mIsSynthesizedForTests; + + newEvent->mRelatedTarget = aRelatedTarget; + newEvent->mRefPoint = aMouseEvent->mRefPoint; + newEvent->mModifiers = aMouseEvent->mModifiers; + if (!aMouseEvent->mFlags.mDispatchedAtLeastOnce && + aMouseEvent->InputSourceSupportsHover()) { + // If we synthesize a pointer event or a mouse event from another event + // which changes a button state whose input soucre supports hover state and + // the source event has not been dispatched yet, we should set to the button + // state of the synthesizing event to previous one. + // Note that we don't need to do this if the input source does not support + // hover state because a WPT check the behavior (see below) and the other + // browsers pass the test even though this is inconsistent behavior. + newEvent->mButton = + sourcePointer ? MouseButton::eNotPressed : MouseButton::ePrimary; + if (aMouseEvent->IsPressingButton()) { + // If the source event has not been dispatched into the DOM yet, we + // need to remove the flag which is being pressed. + newEvent->mButtons = static_cast<decltype(WidgetMouseEvent::mButtons)>( + aMouseEvent->mButtons & + ~MouseButtonsFlagToChange( + static_cast<MouseButton>(aMouseEvent->mButton))); + } else if (aMouseEvent->IsReleasingButton()) { + // If the source event has not been dispatched into the DOM yet, we + // need to add the flag which is being released. + newEvent->mButtons = static_cast<decltype(WidgetMouseEvent::mButtons)>( + aMouseEvent->mButtons | + MouseButtonsFlagToChange( + static_cast<MouseButton>(aMouseEvent->mButton))); + } else { + // The source event does not change the buttons state so that we can + // set mButtons value as-is. + newEvent->mButtons = aMouseEvent->mButtons; + } + // Adjust pressure if it does not matches with mButtons. + // FIXME: We may use wrong pressure value if the source event has not been + // dispatched into the DOM yet. However, fixing this requires to store the + // last pressure value somewhere. + if (newEvent->mButtons && aMouseEvent->mPressure == 0) { + newEvent->mPressure = 0.5f; + } else if (!newEvent->mButtons && aMouseEvent->mPressure != 0) { + newEvent->mPressure = 0; + } else { + newEvent->mPressure = aMouseEvent->mPressure; + } + } else { + // If the event has already been dispatched into the tree, web apps has + // already handled the button state change, so the button state of the + // source event has already synced. + // If the input source does not have hover state, we don't need to modify + // the state because the other browsers behave so and tested by + // pointerevent_attributes_nohover_pointers.html even though this is + // different expectation from + // pointerevent_attributes_hoverable_pointers.html, but the other browsers + // pass both of them. + newEvent->mButton = aMouseEvent->mButton; + newEvent->mButtons = aMouseEvent->mButtons; + newEvent->mPressure = aMouseEvent->mPressure; + } + + newEvent->mInputSource = aMouseEvent->mInputSource; + newEvent->pointerId = aMouseEvent->pointerId; + + return newEvent; +} + +nsIFrame* EventStateManager::DispatchMouseOrPointerEvent( + WidgetMouseEvent* aMouseEvent, EventMessage aMessage, + nsIContent* aTargetContent, nsIContent* aRelatedContent) { + // http://dvcs.w3.org/hg/webevents/raw-file/default/mouse-lock.html#methods + // "[When the mouse is locked on an element...e]vents that require the concept + // of a mouse cursor must not be dispatched (for example: mouseover, + // mouseout). + if (PointerLockManager::IsLocked() && + (aMessage == eMouseLeave || aMessage == eMouseEnter || + aMessage == eMouseOver || aMessage == eMouseOut)) { + mCurrentTargetContent = nullptr; + nsCOMPtr<Element> pointerLockedElement = + PointerLockManager::GetLockedElement(); + if (!pointerLockedElement) { + NS_WARNING("Should have pointer locked element, but didn't."); + return nullptr; + } + return mPresContext->GetPrimaryFrameFor(pointerLockedElement); + } + + mCurrentTargetContent = nullptr; + + if (!aTargetContent) { + return nullptr; + } + + nsCOMPtr<nsIContent> targetContent = aTargetContent; + nsCOMPtr<nsIContent> relatedContent = aRelatedContent; + + UniquePtr<WidgetMouseEvent> dispatchEvent = + CreateMouseOrPointerWidgetEvent(aMouseEvent, aMessage, relatedContent); + + AutoWeakFrame previousTarget = mCurrentTarget; + mCurrentTargetContent = targetContent; + + nsIFrame* targetFrame = nullptr; + + nsEventStatus status = nsEventStatus_eIgnore; + ESMEventCB callback(targetContent); + RefPtr<nsPresContext> presContext = mPresContext; + EventDispatcher::Dispatch(targetContent, presContext, dispatchEvent.get(), + nullptr, &status, &callback); + + if (mPresContext) { + // Although the primary frame was checked in event callback, it may not be + // the same object after event dispatch and handling, so refetch it. + targetFrame = mPresContext->GetPrimaryFrameFor(targetContent); + + // If we are entering/leaving remote content, dispatch a mouse enter/exit + // event to the remote frame. + if (IsTopLevelRemoteTarget(targetContent)) { + if (aMessage == eMouseOut) { + // For remote content, send a puppet widget mouse exit event. + UniquePtr<WidgetMouseEvent> remoteEvent = + CreateMouseOrPointerWidgetEvent(aMouseEvent, eMouseExitFromWidget, + relatedContent); + remoteEvent->mExitFrom = Some(WidgetMouseEvent::ePuppet); + + // mCurrentTarget is set to the new target, so we must reset it to the + // old target and then dispatch a cross-process event. (mCurrentTarget + // will be set back below.) HandleCrossProcessEvent will query for the + // proper target via GetEventTarget which will return mCurrentTarget. + mCurrentTarget = targetFrame; + HandleCrossProcessEvent(remoteEvent.get(), &status); + } else if (aMessage == eMouseOver) { + UniquePtr<WidgetMouseEvent> remoteEvent = + CreateMouseOrPointerWidgetEvent(aMouseEvent, eMouseEnterIntoWidget, + relatedContent); + HandleCrossProcessEvent(remoteEvent.get(), &status); + } + } + } + + mCurrentTargetContent = nullptr; + mCurrentTarget = previousTarget; + + return targetFrame; +} + +static nsIContent* FindCommonAncestor(nsIContent* aNode1, nsIContent* aNode2) { + if (!aNode1 || !aNode2) { + return nullptr; + } + return nsContentUtils::GetCommonFlattenedTreeAncestor(aNode1, aNode2); +} + +class EnterLeaveDispatcher { + public: + EnterLeaveDispatcher(EventStateManager* aESM, nsIContent* aTarget, + nsIContent* aRelatedTarget, + WidgetMouseEvent* aMouseEvent, + EventMessage aEventMessage) + : mESM(aESM), mMouseEvent(aMouseEvent), mEventMessage(aEventMessage) { + nsPIDOMWindowInner* win = + aTarget ? aTarget->OwnerDoc()->GetInnerWindow() : nullptr; + if (aMouseEvent->AsPointerEvent() + ? win && win->HasPointerEnterLeaveEventListeners() + : win && win->HasMouseEnterLeaveEventListeners()) { + mRelatedTarget = + aRelatedTarget ? aRelatedTarget->FindFirstNonChromeOnlyAccessContent() + : nullptr; + nsINode* commonParent = FindCommonAncestor(aTarget, aRelatedTarget); + nsIContent* current = aTarget; + // Note, it is ok if commonParent is null! + while (current && current != commonParent) { + if (!current->ChromeOnlyAccess()) { + mTargets.AppendObject(current); + } + // mouseenter/leave is fired only on elements. + current = current->GetFlattenedTreeParent(); + } + } + } + + // TODO: Convert this to MOZ_CAN_RUN_SCRIPT (bug 1415230) + MOZ_CAN_RUN_SCRIPT_BOUNDARY void Dispatch() { + if (mEventMessage == eMouseEnter || mEventMessage == ePointerEnter) { + for (int32_t i = mTargets.Count() - 1; i >= 0; --i) { + mESM->DispatchMouseOrPointerEvent(mMouseEvent, mEventMessage, + MOZ_KnownLive(mTargets[i]), + mRelatedTarget); + } + } else { + for (int32_t i = 0; i < mTargets.Count(); ++i) { + mESM->DispatchMouseOrPointerEvent(mMouseEvent, mEventMessage, + MOZ_KnownLive(mTargets[i]), + mRelatedTarget); + } + } + } + + // Nothing overwrites anything after constructor. Please remove MOZ_KnownLive + // and MOZ_KNOWN_LIVE if anything marked as such becomes mutable. + const RefPtr<EventStateManager> mESM; + nsCOMArray<nsIContent> mTargets; + MOZ_KNOWN_LIVE nsCOMPtr<nsIContent> mRelatedTarget; + WidgetMouseEvent* mMouseEvent; + EventMessage mEventMessage; +}; + +void EventStateManager::NotifyMouseOut(WidgetMouseEvent* aMouseEvent, + nsIContent* aMovingInto) { + RefPtr<OverOutElementsWrapper> wrapper = GetWrapperByEventID(aMouseEvent); + + // If there is no deepest "leave" event target, that means the last "over" + // target has already been removed from the tree. Therefore, checking only + // the "leave" event target is enough. + if (!wrapper || !wrapper->GetDeepestLeaveEventTarget()) { + return; + } + // Before firing "out" and/or "leave" events, check for recursion + if (wrapper->IsDispatchingOutEventOnLastOverEventTarget()) { + return; + } + + // XXX If a content node is a container of remove content, it should be + // replaced with them and its children should not be visible. Therefore, + // if the deepest "enter" target is not the last "over" target, i.e., the + // last "over" target has been removed from the DOM tree, it means that the + // child/descendant was not replaced by remote content. So, + // wrapper->GetOutEventTaget() may be enough here. + if (RefPtr<nsFrameLoaderOwner> flo = + do_QueryObject(wrapper->GetDeepestLeaveEventTarget())) { + if (BrowsingContext* bc = flo->GetExtantBrowsingContext()) { + if (nsIDocShell* docshell = bc->GetDocShell()) { + if (RefPtr<nsPresContext> presContext = docshell->GetPresContext()) { + EventStateManager* kidESM = presContext->EventStateManager(); + // Not moving into any element in this subdocument + kidESM->NotifyMouseOut(aMouseEvent, nullptr); + } + } + } + } + // That could have caused DOM events which could wreak havoc. Reverify + // things and be careful. + if (!wrapper->GetDeepestLeaveEventTarget()) { + return; + } + + wrapper->WillDispatchOutAndOrLeaveEvent(); + + // Don't touch hover state if aMovingInto is non-null. Caller will update + // hover state itself, and we have optimizations for hover switching between + // two nearby elements both deep in the DOM tree that would be defeated by + // switching the hover state to null here. + bool isPointer = aMouseEvent->mClass == ePointerEventClass; + if (!aMovingInto && !isPointer) { + // Unset :hover + SetContentState(nullptr, ElementState::HOVER); + } + + EnterLeaveDispatcher leaveDispatcher( + this, wrapper->GetDeepestLeaveEventTarget(), aMovingInto, aMouseEvent, + isPointer ? ePointerLeave : eMouseLeave); + + // "out" events hould be fired only when the deepest "leave" event target + // is the last "over" event target. + if (nsCOMPtr<nsIContent> outEventTarget = wrapper->GetOutEventTarget()) { + DispatchMouseOrPointerEvent(aMouseEvent, + isPointer ? ePointerOut : eMouseOut, + outEventTarget, aMovingInto); + } + leaveDispatcher.Dispatch(); + + wrapper->DidDispatchOutAndOrLeaveEvent(); +} + +void EventStateManager::RecomputeMouseEnterStateForRemoteFrame( + Element& aElement) { + if (!mMouseEnterLeaveHelper || + mMouseEnterLeaveHelper->GetDeepestLeaveEventTarget() != &aElement) { + return; + } + + if (BrowserParent* remote = BrowserParent::GetFrom(&aElement)) { + remote->MouseEnterIntoWidget(); + } +} + +void EventStateManager::NotifyMouseOver(WidgetMouseEvent* aMouseEvent, + nsIContent* aContent) { + NS_ASSERTION(aContent, "Mouse must be over something"); + + RefPtr<OverOutElementsWrapper> wrapper = GetWrapperByEventID(aMouseEvent); + + // If we have next "out" event target and it's the new "over" target, we don't + // need to dispatch "out" nor "enter" event. + if (!wrapper || aContent == wrapper->GetOutEventTarget()) { + return; + } + + // Before firing "over" and "enter" events, check for recursion + if (wrapper->IsDispatchingOverEventOn(aContent)) { + return; + } + + // Check to see if we're a subdocument and if so update the parent + // document's ESM state to indicate that the mouse is over the + // content associated with our subdocument. + EnsureDocument(mPresContext); + if (Document* parentDoc = mDocument->GetInProcessParentDocument()) { + if (nsCOMPtr<nsIContent> docContent = mDocument->GetEmbedderElement()) { + if (PresShell* parentPresShell = parentDoc->GetPresShell()) { + RefPtr<EventStateManager> parentESM = + parentPresShell->GetPresContext()->EventStateManager(); + parentESM->NotifyMouseOver(aMouseEvent, docContent); + } + } + } + // Firing the DOM event in the parent document could cause all kinds + // of havoc. Reverify and take care. + if (aContent == wrapper->GetOutEventTarget()) { + return; + } + + // Remember the deepest leave event target as the related content for the + // DispatchMouseOrPointerEvent() call below, since NotifyMouseOut() resets it, + // bug 298477. + nsCOMPtr<nsIContent> deepestLeaveEventTarget = + wrapper->GetDeepestLeaveEventTarget(); + + bool isPointer = aMouseEvent->mClass == ePointerEventClass; + + EnterLeaveDispatcher enterDispatcher(this, aContent, deepestLeaveEventTarget, + aMouseEvent, + isPointer ? ePointerEnter : eMouseEnter); + + if (!isPointer) { + SetContentState(aContent, ElementState::HOVER); + } + + NotifyMouseOut(aMouseEvent, aContent); + + wrapper->WillDispatchOverAndEnterEvent(aContent); + + // Fire mouseover + // XXX If aContent has already been removed from the DOM tree, what should we + // do? At least, dispatching `mouseover` on it is odd. + wrapper->mLastOverFrame = DispatchMouseOrPointerEvent( + aMouseEvent, isPointer ? ePointerOver : eMouseOver, aContent, + deepestLeaveEventTarget); + enterDispatcher.Dispatch(); + + wrapper->DidDispatchOverAndEnterEvent(); +} + +// Returns the center point of the window's client area. This is +// in widget coordinates, i.e. relative to the widget's top-left +// corner, not in screen coordinates, the same units that UIEvent:: +// refpoint is in. It may not be the exact center of the window if +// the platform requires rounding the coordinate. +static LayoutDeviceIntPoint GetWindowClientRectCenter(nsIWidget* aWidget) { + NS_ENSURE_TRUE(aWidget, LayoutDeviceIntPoint(0, 0)); + + LayoutDeviceIntRect rect = aWidget->GetClientBounds(); + LayoutDeviceIntPoint point(rect.x + rect.width / 2, rect.y + rect.height / 2); + int32_t round = aWidget->RoundsWidgetCoordinatesTo(); + point.x = point.x / round * round; + point.y = point.y / round * round; + return point - aWidget->WidgetToScreenOffset(); +} + +void EventStateManager::GeneratePointerEnterExit(EventMessage aMessage, + WidgetMouseEvent* aEvent) { + WidgetPointerEvent pointerEvent(*aEvent); + pointerEvent.mMessage = aMessage; + GenerateMouseEnterExit(&pointerEvent); +} + +/* static */ +void EventStateManager::UpdateLastRefPointOfMouseEvent( + WidgetMouseEvent* aMouseEvent) { + if (aMouseEvent->mMessage != eMouseMove && + aMouseEvent->mMessage != ePointerMove) { + return; + } + + // Mouse movement is reported on the MouseEvent.movement{X,Y} fields. + // Movement is calculated in UIEvent::GetMovementPoint() as: + // previous_mousemove_mRefPoint - current_mousemove_mRefPoint. + if (PointerLockManager::IsLocked() && aMouseEvent->mWidget) { + // The pointer is locked. If the pointer is not located at the center of + // the window, dispatch a synthetic mousemove to return the pointer there. + // Doing this between "real" pointer moves gives the impression that the + // (locked) pointer can continue moving and won't stop at the screen + // boundary. We cancel the synthetic event so that we don't end up + // dispatching the centering move event to content. + aMouseEvent->mLastRefPoint = + GetWindowClientRectCenter(aMouseEvent->mWidget); + + } else if (sLastRefPoint == kInvalidRefPoint) { + // We don't have a valid previous mousemove mRefPoint. This is either + // the first move we've encountered, or the mouse has just re-entered + // the application window. We should report (0,0) movement for this + // case, so make the current and previous mRefPoints the same. + aMouseEvent->mLastRefPoint = aMouseEvent->mRefPoint; + } else { + aMouseEvent->mLastRefPoint = sLastRefPoint; + } +} + +/* static */ +void EventStateManager::ResetPointerToWindowCenterWhilePointerLocked( + WidgetMouseEvent* aMouseEvent) { + MOZ_ASSERT(PointerLockManager::IsLocked()); + if ((aMouseEvent->mMessage != eMouseMove && + aMouseEvent->mMessage != ePointerMove) || + !aMouseEvent->mWidget) { + return; + } + + // We generate pointermove from mousemove event, so only synthesize native + // mouse move and update sSynthCenteringPoint by mousemove event. + bool updateSynthCenteringPoint = aMouseEvent->mMessage == eMouseMove; + + // The pointer is locked. If the pointer is not located at the center of + // the window, dispatch a synthetic mousemove to return the pointer there. + // Doing this between "real" pointer moves gives the impression that the + // (locked) pointer can continue moving and won't stop at the screen + // boundary. We cancel the synthetic event so that we don't end up + // dispatching the centering move event to content. + LayoutDeviceIntPoint center = GetWindowClientRectCenter(aMouseEvent->mWidget); + + if (aMouseEvent->mRefPoint != center && updateSynthCenteringPoint) { + // Mouse move doesn't finish at the center of the window. Dispatch a + // synthetic native mouse event to move the pointer back to the center + // of the window, to faciliate more movement. But first, record that + // we've dispatched a synthetic mouse movement, so we can cancel it + // in the other branch here. + sSynthCenteringPoint = center; + // XXX Once we fix XXX comments in SetPointerLock about this API, we could + // restrict that this API works only in the automation mode or in the + // pointer locked situation. + aMouseEvent->mWidget->SynthesizeNativeMouseMove( + center + aMouseEvent->mWidget->WidgetToScreenOffset(), nullptr); + } else if (aMouseEvent->mRefPoint == sSynthCenteringPoint) { + // This is the "synthetic native" event we dispatched to re-center the + // pointer. Cancel it so we don't expose the centering move to content. + aMouseEvent->StopPropagation(); + // Clear sSynthCenteringPoint so we don't cancel other events + // targeted at the center. + if (updateSynthCenteringPoint) { + sSynthCenteringPoint = kInvalidRefPoint; + } + } +} + +/* static */ +void EventStateManager::UpdateLastPointerPosition( + WidgetMouseEvent* aMouseEvent) { + if (aMouseEvent->mMessage != eMouseMove) { + return; + } + sLastRefPoint = aMouseEvent->mRefPoint; +} + +void EventStateManager::GenerateMouseEnterExit(WidgetMouseEvent* aMouseEvent) { + EnsureDocument(mPresContext); + if (!mDocument) return; + + // Hold onto old target content through the event and reset after. + nsCOMPtr<nsIContent> targetBeforeEvent = mCurrentTargetContent; + + switch (aMouseEvent->mMessage) { + case eMouseMove: + case ePointerMove: + case ePointerDown: + case ePointerGotCapture: { + // Get the target content target (mousemove target == mouseover target) + nsCOMPtr<nsIContent> targetElement = GetEventTargetContent(aMouseEvent); + if (!targetElement) { + // We're always over the document root, even if we're only + // over dead space in a page (whose frame is not associated with + // any content) or in print preview dead space + targetElement = mDocument->GetRootElement(); + } + if (targetElement) { + NotifyMouseOver(aMouseEvent, targetElement); + } + } break; + case ePointerUp: { + // Get the target content target (mousemove target == mouseover target) + nsCOMPtr<nsIContent> targetElement = GetEventTargetContent(aMouseEvent); + if (!targetElement) { + // We're always over the document root, even if we're only + // over dead space in a page (whose frame is not associated with + // any content) or in print preview dead space + targetElement = mDocument->GetRootElement(); + } + if (targetElement) { + RefPtr<OverOutElementsWrapper> helper = + GetWrapperByEventID(aMouseEvent); + if (helper) { + helper->OverrideOverEventTarget(targetElement); + } + NotifyMouseOut(aMouseEvent, nullptr); + } + } break; + case ePointerLeave: + case ePointerCancel: + case eMouseExitFromWidget: { + // This is actually the window mouse exit or pointer leave event. We're + // not moving into any new element. + + RefPtr<OverOutElementsWrapper> helper = GetWrapperByEventID(aMouseEvent); + if (helper && helper->mLastOverFrame && + nsContentUtils::GetTopLevelWidget(aMouseEvent->mWidget) != + nsContentUtils::GetTopLevelWidget( + helper->mLastOverFrame->GetNearestWidget())) { + // the Mouse/PointerOut event widget doesn't have same top widget with + // mLastOverFrame, it's a spurious event for mLastOverFrame + break; + } + + // Reset sLastRefPoint, so that we'll know not to report any + // movement the next time we re-enter the window. + sLastRefPoint = kInvalidRefPoint; + + NotifyMouseOut(aMouseEvent, nullptr); + } break; + default: + break; + } + + // reset mCurretTargetContent to what it was + mCurrentTargetContent = targetBeforeEvent; +} + +OverOutElementsWrapper* EventStateManager::GetWrapperByEventID( + WidgetMouseEvent* aEvent) { + WidgetPointerEvent* pointer = aEvent->AsPointerEvent(); + if (!pointer) { + MOZ_ASSERT(aEvent->AsMouseEvent() != nullptr); + if (!mMouseEnterLeaveHelper) { + mMouseEnterLeaveHelper = new OverOutElementsWrapper(); + } + return mMouseEnterLeaveHelper; + } + return mPointersEnterLeaveHelper.GetOrInsertNew(pointer->pointerId); +} + +/* static */ +void EventStateManager::SetPointerLock(nsIWidget* aWidget, + nsPresContext* aPresContext) { + // Reset mouse wheel transaction + WheelTransaction::EndTransaction(); + + // Deal with DnD events + nsCOMPtr<nsIDragService> dragService = + do_GetService("@mozilla.org/widget/dragservice;1"); + + if (PointerLockManager::IsLocked()) { + MOZ_ASSERT(aWidget, "Locking pointer requires a widget"); + MOZ_ASSERT(aPresContext, "Locking pointer requires a presContext"); + + // Release all pointer capture when a pointer lock is successfully applied + // on an element. + PointerEventHandler::ReleaseAllPointerCapture(); + + // Store the last known ref point so we can reposition the pointer after + // unlock. + sPreLockScreenPoint = LayoutDeviceIntPoint::Round( + sLastScreenPoint * aPresContext->CSSToDevPixelScale()); + + // Fire a synthetic mouse move to ensure event state is updated. We first + // set the mouse to the center of the window, so that the mouse event + // doesn't report any movement. + // XXX Cannot we do synthesize the native mousemove in the parent process + // with calling LockNativePointer below? Then, we could make this API + // work only in the automation mode. + sLastRefPoint = GetWindowClientRectCenter(aWidget); + aWidget->SynthesizeNativeMouseMove( + sLastRefPoint + aWidget->WidgetToScreenOffset(), nullptr); + + // Suppress DnD + if (dragService) { + dragService->Suppress(); + } + + // Activate native pointer lock on platforms where it is required (Wayland) + aWidget->LockNativePointer(); + } else { + if (aWidget) { + // Deactivate native pointer lock on platforms where it is required + aWidget->UnlockNativePointer(); + } + + // Reset SynthCenteringPoint to invalid so that next time we start + // locking pointer, it has its initial value. + sSynthCenteringPoint = kInvalidRefPoint; + if (aWidget) { + // Unlocking, so return pointer to the original position by firing a + // synthetic mouse event. We first reset sLastRefPoint to its + // pre-pointerlock position, so that the synthetic mouse event reports + // no movement. + sLastRefPoint = sPreLockScreenPoint - aWidget->WidgetToScreenOffset(); + // XXX Cannot we do synthesize the native mousemove in the parent process + // with calling `UnlockNativePointer` above? Then, we could make this + // API work only in the automation mode. + aWidget->SynthesizeNativeMouseMove(sPreLockScreenPoint, nullptr); + } + + // Unsuppress DnD + if (dragService) { + dragService->Unsuppress(); + } + } +} + +void EventStateManager::GenerateDragDropEnterExit(nsPresContext* aPresContext, + WidgetDragEvent* aDragEvent) { + // Hold onto old target content through the event and reset after. + nsCOMPtr<nsIContent> targetBeforeEvent = mCurrentTargetContent; + + switch (aDragEvent->mMessage) { + case eDragOver: { + // when dragging from one frame to another, events are fired in the + // order: dragexit, dragenter, dragleave + if (sLastDragOverFrame != mCurrentTarget) { + // We'll need the content, too, to check if it changed separately from + // the frames. + nsCOMPtr<nsIContent> lastContent; + nsCOMPtr<nsIContent> targetContent; + mCurrentTarget->GetContentForEvent(aDragEvent, + getter_AddRefs(targetContent)); + if (targetContent && targetContent->IsText()) { + targetContent = targetContent->GetFlattenedTreeParent(); + } + + if (sLastDragOverFrame) { + // The frame has changed but the content may not have. Check before + // dispatching to content + sLastDragOverFrame->GetContentForEvent(aDragEvent, + getter_AddRefs(lastContent)); + if (lastContent && lastContent->IsText()) { + lastContent = lastContent->GetFlattenedTreeParent(); + } + + RefPtr<nsPresContext> presContext = sLastDragOverFrame->PresContext(); + FireDragEnterOrExit(presContext, aDragEvent, eDragExit, targetContent, + lastContent, sLastDragOverFrame); + nsIContent* target = sLastDragOverFrame + ? sLastDragOverFrame.GetFrame()->GetContent() + : nullptr; + // XXXedgar, look like we need to consider fission OOP iframe, too. + if (IsTopLevelRemoteTarget(target)) { + // Dragging something and moving from web content to chrome only + // fires dragexit and dragleave to xul:browser. We have to forward + // dragexit to sLastDragOverFrame when its content is a remote + // target. We don't forward dragleave since it's generated from + // dragexit. + WidgetDragEvent remoteEvent(aDragEvent->IsTrusted(), eDragExit, + aDragEvent->mWidget); + remoteEvent.AssignDragEventData(*aDragEvent, true); + remoteEvent.mFlags.mIsSynthesizedForTests = + aDragEvent->mFlags.mIsSynthesizedForTests; + nsEventStatus remoteStatus = nsEventStatus_eIgnore; + HandleCrossProcessEvent(&remoteEvent, &remoteStatus); + } + } + + AutoWeakFrame currentTraget = mCurrentTarget; + FireDragEnterOrExit(aPresContext, aDragEvent, eDragEnter, lastContent, + targetContent, currentTraget); + + if (sLastDragOverFrame) { + RefPtr<nsPresContext> presContext = sLastDragOverFrame->PresContext(); + FireDragEnterOrExit(presContext, aDragEvent, eDragLeave, + targetContent, lastContent, sLastDragOverFrame); + } + + sLastDragOverFrame = mCurrentTarget; + } + } break; + + case eDragExit: { + // This is actually the window mouse exit event. + if (sLastDragOverFrame) { + nsCOMPtr<nsIContent> lastContent; + sLastDragOverFrame->GetContentForEvent(aDragEvent, + getter_AddRefs(lastContent)); + + RefPtr<nsPresContext> lastDragOverFramePresContext = + sLastDragOverFrame->PresContext(); + FireDragEnterOrExit(lastDragOverFramePresContext, aDragEvent, eDragExit, + nullptr, lastContent, sLastDragOverFrame); + FireDragEnterOrExit(lastDragOverFramePresContext, aDragEvent, + eDragLeave, nullptr, lastContent, + sLastDragOverFrame); + + sLastDragOverFrame = nullptr; + } + } break; + + default: + break; + } + + // reset mCurretTargetContent to what it was + mCurrentTargetContent = targetBeforeEvent; + + // Now flush all pending notifications, for better responsiveness. + FlushLayout(aPresContext); +} + +void EventStateManager::FireDragEnterOrExit(nsPresContext* aPresContext, + WidgetDragEvent* aDragEvent, + EventMessage aMessage, + nsIContent* aRelatedTarget, + nsIContent* aTargetContent, + AutoWeakFrame& aTargetFrame) { + MOZ_ASSERT(aMessage == eDragLeave || aMessage == eDragExit || + aMessage == eDragEnter); + nsEventStatus status = nsEventStatus_eIgnore; + WidgetDragEvent event(aDragEvent->IsTrusted(), aMessage, aDragEvent->mWidget); + event.AssignDragEventData(*aDragEvent, false); + event.mFlags.mIsSynthesizedForTests = + aDragEvent->mFlags.mIsSynthesizedForTests; + event.mRelatedTarget = aRelatedTarget; + if (aMessage == eDragExit && !StaticPrefs::dom_event_dragexit_enabled()) { + event.mFlags.mOnlyChromeDispatch = true; + } + + mCurrentTargetContent = aTargetContent; + + if (aTargetContent != aRelatedTarget) { + // XXX This event should still go somewhere!! + if (aTargetContent) { + EventDispatcher::Dispatch(aTargetContent, aPresContext, &event, nullptr, + &status); + } + + // adjust the drag hover if the dragenter event was cancelled or this is a + // drag exit + if (status == nsEventStatus_eConsumeNoDefault || aMessage == eDragExit) { + SetContentState((aMessage == eDragEnter) ? aTargetContent : nullptr, + ElementState::DRAGOVER); + } + + // collect any changes to moz cursor settings stored in the event's + // data transfer. + UpdateDragDataTransfer(&event); + } + + // Finally dispatch the event to the frame + if (aTargetFrame) { + aTargetFrame->HandleEvent(aPresContext, &event, &status); + } +} + +void EventStateManager::UpdateDragDataTransfer(WidgetDragEvent* dragEvent) { + NS_ASSERTION(dragEvent, "drag event is null in UpdateDragDataTransfer!"); + if (!dragEvent->mDataTransfer) { + return; + } + + nsCOMPtr<nsIDragSession> dragSession = nsContentUtils::GetDragSession(); + + if (dragSession) { + // the initial dataTransfer is the one from the dragstart event that + // was set on the dragSession when the drag began. + RefPtr<DataTransfer> initialDataTransfer = dragSession->GetDataTransfer(); + if (initialDataTransfer) { + // retrieve the current moz cursor setting and save it. + nsAutoString mozCursor; + dragEvent->mDataTransfer->GetMozCursor(mozCursor); + initialDataTransfer->SetMozCursor(mozCursor); + } + } +} + +nsresult EventStateManager::SetClickCount(WidgetMouseEvent* aEvent, + nsEventStatus* aStatus, + nsIContent* aOverrideClickTarget) { + nsCOMPtr<nsIContent> mouseContent = aOverrideClickTarget; + if (!mouseContent && mCurrentTarget) { + mCurrentTarget->GetContentForEvent(aEvent, getter_AddRefs(mouseContent)); + } + if (mouseContent && mouseContent->IsText()) { + nsINode* parent = mouseContent->GetFlattenedTreeParentNode(); + if (parent && parent->IsContent()) { + mouseContent = parent->AsContent(); + } + } + + LastMouseDownInfo& mouseDownInfo = GetLastMouseDownInfo(aEvent->mButton); + if (aEvent->mMessage == eMouseDown) { + mouseDownInfo.mLastMouseDownContent = + !aEvent->mClickEventPrevented ? mouseContent : nullptr; + + if (mouseDownInfo.mLastMouseDownContent) { + if (HTMLInputElement* input = HTMLInputElement::FromNodeOrNull( + mouseDownInfo.mLastMouseDownContent)) { + mouseDownInfo.mLastMouseDownInputControlType = + Some(input->ControlType()); + } else if (mouseDownInfo.mLastMouseDownContent + ->IsInNativeAnonymousSubtree()) { + if (HTMLInputElement* input = HTMLInputElement::FromNodeOrNull( + mouseDownInfo.mLastMouseDownContent + ->GetFlattenedTreeParent())) { + mouseDownInfo.mLastMouseDownInputControlType = + Some(input->ControlType()); + } + } + } + } else { + aEvent->mClickTarget = + !aEvent->mClickEventPrevented + ? GetCommonAncestorForMouseUp( + mouseContent, mouseDownInfo.mLastMouseDownContent, + mouseDownInfo.mLastMouseDownInputControlType) + : nullptr; + if (aEvent->mClickTarget) { + aEvent->mClickCount = mouseDownInfo.mClickCount; + mouseDownInfo.mClickCount = 0; + } else { + aEvent->mClickCount = 0; + } + mouseDownInfo.mLastMouseDownContent = nullptr; + mouseDownInfo.mLastMouseDownInputControlType = Nothing(); + } + + return NS_OK; +} + +// static +bool EventStateManager::EventCausesClickEvents( + const WidgetMouseEvent& aMouseEvent) { + if (NS_WARN_IF(aMouseEvent.mMessage != eMouseUp)) { + return false; + } + // If the mouseup event is synthesized event, we don't need to dispatch + // click events. + if (!aMouseEvent.IsReal()) { + return false; + } + // If mouse is still over same element, clickcount will be > 1. + // If it has moved it will be zero, so no click. + if (!aMouseEvent.mClickCount || !aMouseEvent.mClickTarget) { + return false; + } + // If click event was explicitly prevented, we shouldn't dispatch it. + if (aMouseEvent.mClickEventPrevented) { + return false; + } + // Check that the window isn't disabled before firing a click + // (see bug 366544). + return !(aMouseEvent.mWidget && !aMouseEvent.mWidget->IsEnabled()); +} + +nsresult EventStateManager::InitAndDispatchClickEvent( + WidgetMouseEvent* aMouseUpEvent, nsEventStatus* aStatus, + EventMessage aMessage, PresShell* aPresShell, nsIContent* aMouseUpContent, + AutoWeakFrame aCurrentTarget, bool aNoContentDispatch, + nsIContent* aOverrideClickTarget) { + MOZ_ASSERT(aMouseUpEvent); + MOZ_ASSERT(EventCausesClickEvents(*aMouseUpEvent)); + MOZ_ASSERT(aMouseUpContent || aCurrentTarget || aOverrideClickTarget); + + WidgetMouseEvent event(aMouseUpEvent->IsTrusted(), aMessage, + aMouseUpEvent->mWidget, WidgetMouseEvent::eReal); + + event.mRefPoint = aMouseUpEvent->mRefPoint; + event.mClickCount = aMouseUpEvent->mClickCount; + event.mModifiers = aMouseUpEvent->mModifiers; + event.mButtons = aMouseUpEvent->mButtons; + event.mTimeStamp = aMouseUpEvent->mTimeStamp; + event.mFlags.mOnlyChromeDispatch = aNoContentDispatch; + event.mFlags.mNoContentDispatch = aNoContentDispatch; + event.mButton = aMouseUpEvent->mButton; + event.pointerId = aMouseUpEvent->pointerId; + event.mInputSource = aMouseUpEvent->mInputSource; + nsIContent* target = aMouseUpContent; + nsIFrame* targetFrame = aCurrentTarget; + if (aOverrideClickTarget) { + target = aOverrideClickTarget; + targetFrame = aOverrideClickTarget->GetPrimaryFrame(); + } + + if (!target->IsInComposedDoc()) { + return NS_OK; + } + + // Use local event status for each click event dispatching since it'll be + // cleared by EventStateManager::PreHandleEvent(). Therefore, dispatching + // an event means that previous event status will be ignored. + nsEventStatus status = nsEventStatus_eIgnore; + nsresult rv = aPresShell->HandleEventWithTarget( + &event, targetFrame, MOZ_KnownLive(target), &status); + + // Copy mMultipleActionsPrevented flag from a click event to the mouseup + // event only when it's set to true. It may be set to true if an editor has + // already handled it. This is important to avoid two or more default + // actions handled here. + aMouseUpEvent->mFlags.mMultipleActionsPrevented |= + event.mFlags.mMultipleActionsPrevented; + // If current status is nsEventStatus_eConsumeNoDefault, we don't need to + // overwrite it. + if (*aStatus == nsEventStatus_eConsumeNoDefault) { + return rv; + } + // If new status is nsEventStatus_eConsumeNoDefault or + // nsEventStatus_eConsumeDoDefault, use it. + if (status == nsEventStatus_eConsumeNoDefault || + status == nsEventStatus_eConsumeDoDefault) { + *aStatus = status; + return rv; + } + // Otherwise, keep the original status. + return rv; +} + +nsresult EventStateManager::PostHandleMouseUp( + WidgetMouseEvent* aMouseUpEvent, nsEventStatus* aStatus, + nsIContent* aOverrideClickTarget) { + MOZ_ASSERT(aMouseUpEvent); + MOZ_ASSERT(EventCausesClickEvents(*aMouseUpEvent)); + MOZ_ASSERT(aStatus); + + RefPtr<PresShell> presShell = mPresContext->GetPresShell(); + if (!presShell) { + return NS_OK; + } + + nsCOMPtr<nsIContent> clickTarget = + nsIContent::FromEventTargetOrNull(aMouseUpEvent->mClickTarget); + NS_ENSURE_STATE(clickTarget); + + // Fire click events if the event target is still available. + // Note that do not include the eMouseUp event's status since we ignore it + // for compatibility with the other browsers. + nsEventStatus status = nsEventStatus_eIgnore; + nsresult rv = DispatchClickEvents(presShell, aMouseUpEvent, &status, + clickTarget, aOverrideClickTarget); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + // Do not do anything if preceding click events are consumed. + // Note that Chromium dispatches "paste" event and actually pates clipboard + // text into focused editor even if the preceding click events are consumed. + // However, this is different from our traditional behavior and does not + // conform to DOM events. If we need to keep compatibility with Chromium, + // we should change it later. + if (status == nsEventStatus_eConsumeNoDefault) { + *aStatus = nsEventStatus_eConsumeNoDefault; + return NS_OK; + } + + // Handle middle click paste if it's enabled and the mouse button is middle. + if (aMouseUpEvent->mButton != MouseButton::eMiddle || + !WidgetMouseEvent::IsMiddleClickPasteEnabled()) { + return NS_OK; + } + DebugOnly<nsresult> rvIgnored = + HandleMiddleClickPaste(presShell, aMouseUpEvent, &status, nullptr); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored), + "Failed to paste for a middle click"); + + // If new status is nsEventStatus_eConsumeNoDefault or + // nsEventStatus_eConsumeDoDefault, use it. + if (*aStatus != nsEventStatus_eConsumeNoDefault && + (status == nsEventStatus_eConsumeNoDefault || + status == nsEventStatus_eConsumeDoDefault)) { + *aStatus = status; + } + + // Don't return error even if middle mouse paste fails since we haven't + // handled it here. + return NS_OK; +} + +nsresult EventStateManager::DispatchClickEvents( + PresShell* aPresShell, WidgetMouseEvent* aMouseUpEvent, + nsEventStatus* aStatus, nsIContent* aClickTarget, + nsIContent* aOverrideClickTarget) { + MOZ_ASSERT(aPresShell); + MOZ_ASSERT(aMouseUpEvent); + MOZ_ASSERT(EventCausesClickEvents(*aMouseUpEvent)); + MOZ_ASSERT(aStatus); + MOZ_ASSERT(aClickTarget || aOverrideClickTarget); + + bool notDispatchToContents = + (aMouseUpEvent->mButton == MouseButton::eMiddle || + aMouseUpEvent->mButton == MouseButton::eSecondary); + + bool fireAuxClick = notDispatchToContents; + + AutoWeakFrame currentTarget = aClickTarget->GetPrimaryFrame(); + nsresult rv = InitAndDispatchClickEvent( + aMouseUpEvent, aStatus, eMouseClick, aPresShell, aClickTarget, + currentTarget, notDispatchToContents, aOverrideClickTarget); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + // Fire auxclick event if necessary. + if (fireAuxClick && *aStatus != nsEventStatus_eConsumeNoDefault && + aClickTarget && aClickTarget->IsInComposedDoc()) { + rv = InitAndDispatchClickEvent(aMouseUpEvent, aStatus, eMouseAuxClick, + aPresShell, aClickTarget, currentTarget, + false, aOverrideClickTarget); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "Failed to dispatch eMouseAuxClick"); + } + + // Fire double click event if click count is 2. + if (aMouseUpEvent->mClickCount == 2 && !fireAuxClick && aClickTarget && + aClickTarget->IsInComposedDoc()) { + rv = InitAndDispatchClickEvent(aMouseUpEvent, aStatus, eMouseDoubleClick, + aPresShell, aClickTarget, currentTarget, + notDispatchToContents, aOverrideClickTarget); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + } + + return rv; +} + +nsresult EventStateManager::HandleMiddleClickPaste( + PresShell* aPresShell, WidgetMouseEvent* aMouseEvent, + nsEventStatus* aStatus, EditorBase* aEditorBase) { + MOZ_ASSERT(aPresShell); + MOZ_ASSERT(aMouseEvent); + MOZ_ASSERT((aMouseEvent->mMessage == eMouseAuxClick && + aMouseEvent->mButton == MouseButton::eMiddle) || + EventCausesClickEvents(*aMouseEvent)); + MOZ_ASSERT(aStatus); + MOZ_ASSERT(*aStatus != nsEventStatus_eConsumeNoDefault); + + // Even if we're called twice or more for a mouse operation, we should + // handle only once. Although mMultipleActionsPrevented may be set to + // true by different event handler in the future, we can use it for now. + if (aMouseEvent->mFlags.mMultipleActionsPrevented) { + return NS_OK; + } + aMouseEvent->mFlags.mMultipleActionsPrevented = true; + + RefPtr<Selection> selection; + if (aEditorBase) { + selection = aEditorBase->GetSelection(); + if (NS_WARN_IF(!selection)) { + return NS_ERROR_FAILURE; + } + } else { + Document* document = aPresShell->GetDocument(); + if (NS_WARN_IF(!document)) { + return NS_ERROR_FAILURE; + } + selection = nsCopySupport::GetSelectionForCopy(document); + if (NS_WARN_IF(!selection)) { + return NS_ERROR_FAILURE; + } + + const nsRange* range = selection->GetRangeAt(0); + if (range) { + nsINode* target = range->GetStartContainer(); + if (target && target->OwnerDoc()->IsInChromeDocShell()) { + // In Chrome document, limit middle-click pasting to only the editor + // because it looks odd if pasting works in the focused editor when you + // middle-click toolbar or something which are far from the editor. + // However, as DevTools especially Web Console module assumes that paste + // event will be fired when middle-click even on not editor, don't limit + // it. + return NS_OK; + } + } + } + + // Don't modify selection here because we've already set caret to the point + // at "mousedown" event. + + int32_t clipboardType = nsIClipboard::kGlobalClipboard; + nsCOMPtr<nsIClipboard> clipboardService = + do_GetService("@mozilla.org/widget/clipboard;1"); + if (clipboardService && clipboardService->IsClipboardTypeSupported( + nsIClipboard::kSelectionClipboard)) { + clipboardType = nsIClipboard::kSelectionClipboard; + } + + // Fire ePaste event by ourselves since we need to dispatch "paste" event + // even if the middle click event was consumed for compatibility with + // Chromium. + if (!nsCopySupport::FireClipboardEvent(ePaste, clipboardType, aPresShell, + selection)) { + *aStatus = nsEventStatus_eConsumeNoDefault; + return NS_OK; + } + + // Although we've fired "paste" event, there is no editor to accept the + // clipboard content. + if (!aEditorBase) { + return NS_OK; + } + + // Check if the editor is still the good target to paste. + if (aEditorBase->Destroyed() || aEditorBase->IsReadonly()) { + // XXX Should we consume the event when the editor is readonly and/or + // disabled? + return NS_OK; + } + + // The selection may have been modified during reflow. Therefore, we + // should adjust event target to pass IsAcceptableInputEvent(). + const nsRange* range = selection->GetRangeAt(0); + if (!range) { + return NS_OK; + } + WidgetMouseEvent mouseEvent(*aMouseEvent); + mouseEvent.mOriginalTarget = range->GetStartContainer(); + if (NS_WARN_IF(!mouseEvent.mOriginalTarget) || + !aEditorBase->IsAcceptableInputEvent(&mouseEvent)) { + return NS_OK; + } + + // If Control key is pressed, we should paste clipboard content as + // quotation. Otherwise, paste it as is. + if (aMouseEvent->IsControl()) { + DebugOnly<nsresult> rv = aEditorBase->PasteAsQuotationAsAction( + clipboardType, EditorBase::DispatchPasteEvent::No); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "Failed to paste as quotation"); + } else { + DebugOnly<nsresult> rv = aEditorBase->PasteAsAction( + clipboardType, EditorBase::DispatchPasteEvent::No); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "Failed to paste"); + } + *aStatus = nsEventStatus_eConsumeNoDefault; + + return NS_OK; +} + +void EventStateManager::ConsumeInteractionData( + Record<nsString, dom::InteractionData>& aInteractions) { + OnTypingInteractionEnded(); + + aInteractions.Entries().Clear(); + auto newEntry = aInteractions.Entries().AppendElement(); + newEntry->mKey = u"Typing"_ns; + newEntry->mValue = gTypingInteraction; + gTypingInteraction = {}; +} + +nsIFrame* EventStateManager::GetEventTarget() { + PresShell* presShell; + if (mCurrentTarget || !mPresContext || + !(presShell = mPresContext->GetPresShell())) { + return mCurrentTarget; + } + + if (mCurrentTargetContent) { + mCurrentTarget = mPresContext->GetPrimaryFrameFor(mCurrentTargetContent); + if (mCurrentTarget) { + return mCurrentTarget; + } + } + + nsIFrame* frame = presShell->GetCurrentEventFrame(); + return (mCurrentTarget = frame); +} + +already_AddRefed<nsIContent> EventStateManager::GetEventTargetContent( + WidgetEvent* aEvent) { + if (aEvent && (aEvent->mMessage == eFocus || aEvent->mMessage == eBlur)) { + nsCOMPtr<nsIContent> content = GetFocusedElement(); + return content.forget(); + } + + if (mCurrentTargetContent) { + nsCOMPtr<nsIContent> content = mCurrentTargetContent; + return content.forget(); + } + + nsCOMPtr<nsIContent> content; + if (PresShell* presShell = mPresContext->GetPresShell()) { + content = presShell->GetEventTargetContent(aEvent); + } + + // Some events here may set mCurrentTarget but not set the corresponding + // event target in the PresShell. + if (!content && mCurrentTarget) { + mCurrentTarget->GetContentForEvent(aEvent, getter_AddRefs(content)); + } + + return content.forget(); +} + +static Element* GetLabelTarget(nsIContent* aPossibleLabel) { + mozilla::dom::HTMLLabelElement* label = + mozilla::dom::HTMLLabelElement::FromNode(aPossibleLabel); + if (!label) return nullptr; + + return label->GetLabeledElement(); +} + +/* static */ +inline void EventStateManager::DoStateChange(Element* aElement, + ElementState aState, + bool aAddState) { + if (aAddState) { + aElement->AddStates(aState); + } else { + aElement->RemoveStates(aState); + } +} + +/* static */ +inline void EventStateManager::DoStateChange(nsIContent* aContent, + ElementState aState, + bool aStateAdded) { + if (aContent->IsElement()) { + DoStateChange(aContent->AsElement(), aState, aStateAdded); + } +} + +/* static */ +void EventStateManager::UpdateAncestorState(nsIContent* aStartNode, + nsIContent* aStopBefore, + ElementState aState, + bool aAddState) { + for (; aStartNode && aStartNode != aStopBefore; + aStartNode = aStartNode->GetFlattenedTreeParent()) { + // We might be starting with a non-element (e.g. a text node) and + // if someone is doing something weird might be ending with a + // non-element too (e.g. a document fragment) + if (!aStartNode->IsElement()) { + continue; + } + Element* element = aStartNode->AsElement(); + DoStateChange(element, aState, aAddState); + Element* labelTarget = GetLabelTarget(element); + if (labelTarget) { + DoStateChange(labelTarget, aState, aAddState); + } + } + + if (aAddState) { + // We might be in a situation where a node was in hover both + // because it was hovered and because the label for it was + // hovered, and while we stopped hovering the node the label is + // still hovered. Or we might have had two nested labels for the + // same node, and while one is no longer hovered the other still + // is. In that situation, the label that's still hovered will be + // aStopBefore or some ancestor of it, and the call we just made + // to UpdateAncestorState with aAddState = false would have + // removed the hover state from the node. But the node should + // still be in hover state. To handle this situation we need to + // keep walking up the tree and any time we find a label mark its + // corresponding node as still in our state. + for (; aStartNode; aStartNode = aStartNode->GetFlattenedTreeParent()) { + if (!aStartNode->IsElement()) { + continue; + } + + Element* labelTarget = GetLabelTarget(aStartNode->AsElement()); + if (labelTarget && !labelTarget->State().HasState(aState)) { + DoStateChange(labelTarget, aState, true); + } + } + } +} + +// static +bool CanContentHaveActiveState(nsIContent& aContent) { + // Editable content can never become active since their default actions + // are disabled. Watch out for editable content in native anonymous + // subtrees though, as they belong to text controls. + return !aContent.IsEditable() || aContent.IsInNativeAnonymousSubtree(); +} + +bool EventStateManager::SetContentState(nsIContent* aContent, + ElementState aState) { + MOZ_ASSERT(ManagesState(aState), "Unexpected state"); + + nsCOMPtr<nsIContent> notifyContent1; + nsCOMPtr<nsIContent> notifyContent2; + bool updateAncestors; + + if (aState == ElementState::HOVER || aState == ElementState::ACTIVE) { + // Hover and active are hierarchical + updateAncestors = true; + + // check to see that this state is allowed by style. Check dragover too? + // XXX Is this even what we want? + if (mCurrentTarget && + mCurrentTarget->StyleUI()->UserInput() == StyleUserInput::None) { + return false; + } + + if (aState == ElementState::ACTIVE) { + if (aContent && !CanContentHaveActiveState(*aContent)) { + aContent = nullptr; + } + if (aContent != mActiveContent) { + notifyContent1 = aContent; + notifyContent2 = mActiveContent; + mActiveContent = aContent; + } + } else { + NS_ASSERTION(aState == ElementState::HOVER, "How did that happen?"); + nsIContent* newHover; + + if (mPresContext->IsDynamic()) { + newHover = aContent; + } else { + NS_ASSERTION(!aContent || aContent->GetComposedDoc() == + mPresContext->PresShell()->GetDocument(), + "Unexpected document"); + nsIFrame* frame = aContent ? aContent->GetPrimaryFrame() : nullptr; + if (frame && nsLayoutUtils::IsViewportScrollbarFrame(frame)) { + // The scrollbars of viewport should not ignore the hover state. + // Because they are *not* the content of the web page. + newHover = aContent; + } else { + // All contents of the web page should ignore the hover state. + newHover = nullptr; + } + } + + if (newHover != mHoverContent) { + notifyContent1 = newHover; + notifyContent2 = mHoverContent; + mHoverContent = newHover; + } + } + } else { + updateAncestors = false; + if (aState == ElementState::DRAGOVER) { + if (aContent != sDragOverContent) { + notifyContent1 = aContent; + notifyContent2 = sDragOverContent; + sDragOverContent = aContent; + } + } else if (aState == ElementState::URLTARGET) { + if (aContent != mURLTargetContent) { + notifyContent1 = aContent; + notifyContent2 = mURLTargetContent; + mURLTargetContent = aContent; + } + } + } + + // We need to keep track of which of notifyContent1 and notifyContent2 is + // getting the state set and which is getting it unset. If both are + // non-null, then notifyContent1 is having the state set and notifyContent2 + // is having it unset. But if one of them is null, we need to keep track of + // the right thing for notifyContent1 explicitly. + bool content1StateSet = true; + if (!notifyContent1) { + // This is ok because FindCommonAncestor wouldn't find anything + // anyway if notifyContent1 is null. + notifyContent1 = notifyContent2; + notifyContent2 = nullptr; + content1StateSet = false; + } + + if (notifyContent1 && mPresContext) { + EnsureDocument(mPresContext); + if (mDocument) { + nsAutoScriptBlocker scriptBlocker; + + if (updateAncestors) { + nsCOMPtr<nsIContent> commonAncestor = + FindCommonAncestor(notifyContent1, notifyContent2); + if (notifyContent2) { + // It's very important to first notify the state removal and + // then the state addition, because due to labels it's + // possible that we're removing state from some element but + // then adding it again (say because mHoverContent changed + // from a control to its label). + UpdateAncestorState(notifyContent2, commonAncestor, aState, false); + } + UpdateAncestorState(notifyContent1, commonAncestor, aState, + content1StateSet); + } else { + if (notifyContent2) { + DoStateChange(notifyContent2, aState, false); + } + DoStateChange(notifyContent1, aState, content1StateSet); + } + } + } + + return true; +} + +void EventStateManager::RemoveNodeFromChainIfNeeded(ElementState aState, + nsIContent* aContentRemoved, + bool aNotify) { + MOZ_ASSERT(aState == ElementState::HOVER || aState == ElementState::ACTIVE); + if (!aContentRemoved->IsElement() || + !aContentRemoved->AsElement()->State().HasState(aState)) { + return; + } + + nsCOMPtr<nsIContent>& leaf = + aState == ElementState::HOVER ? mHoverContent : mActiveContent; + + MOZ_ASSERT(leaf); + // These two NS_ASSERTIONS below can fail for Shadow DOM sometimes, and it's + // not clear how to best handle it, see + // https://github.com/whatwg/html/issues/4795 and bug 1551621. + NS_ASSERTION( + nsContentUtils::ContentIsFlattenedTreeDescendantOf(leaf, aContentRemoved), + "Flat tree and active / hover chain got out of sync"); + + nsIContent* newLeaf = aContentRemoved->GetFlattenedTreeParent(); + MOZ_ASSERT(!newLeaf || newLeaf->IsElement()); + NS_ASSERTION(!newLeaf || newLeaf->AsElement()->State().HasState(aState), + "State got out of sync because of shadow DOM"); + if (aNotify) { + SetContentState(newLeaf, aState); + } else { + // We don't update the removed content's state here, since removing NAC + // happens from layout and we don't really want to notify at that point or + // what not. + // + // Also, NAC is not observable and NAC being removed will go away soon. + leaf = newLeaf; + } + MOZ_ASSERT(leaf == newLeaf || (aState == ElementState::ACTIVE && !leaf && + !CanContentHaveActiveState(*newLeaf))); +} + +void EventStateManager::NativeAnonymousContentRemoved(nsIContent* aContent) { + MOZ_ASSERT(aContent->IsRootOfNativeAnonymousSubtree()); + RemoveNodeFromChainIfNeeded(ElementState::HOVER, aContent, false); + RemoveNodeFromChainIfNeeded(ElementState::ACTIVE, aContent, false); + + nsCOMPtr<nsIContent>& lastLeftMouseDownContent = + mLastLeftMouseDownInfo.mLastMouseDownContent; + if (lastLeftMouseDownContent && + nsContentUtils::ContentIsFlattenedTreeDescendantOf( + lastLeftMouseDownContent, aContent)) { + lastLeftMouseDownContent = aContent->GetFlattenedTreeParent(); + } + + nsCOMPtr<nsIContent>& lastMiddleMouseDownContent = + mLastMiddleMouseDownInfo.mLastMouseDownContent; + if (lastMiddleMouseDownContent && + nsContentUtils::ContentIsFlattenedTreeDescendantOf( + lastMiddleMouseDownContent, aContent)) { + lastMiddleMouseDownContent = aContent->GetFlattenedTreeParent(); + } + + nsCOMPtr<nsIContent>& lastRightMouseDownContent = + mLastRightMouseDownInfo.mLastMouseDownContent; + if (lastRightMouseDownContent && + nsContentUtils::ContentIsFlattenedTreeDescendantOf( + lastRightMouseDownContent, aContent)) { + lastRightMouseDownContent = aContent->GetFlattenedTreeParent(); + } +} + +void EventStateManager::ContentRemoved(Document* aDocument, + nsIContent* aContent) { + /* + * Anchor and area elements when focused or hovered might make the UI to show + * the current link. We want to make sure that the UI gets informed when they + * are actually removed from the DOM. + */ + if (aContent->IsAnyOfHTMLElements(nsGkAtoms::a, nsGkAtoms::area) && + (aContent->AsElement()->State().HasAtLeastOneOfStates( + ElementState::FOCUS | ElementState::HOVER))) { + Element* element = aContent->AsElement(); + element->LeaveLink(element->GetPresContext(Element::eForComposedDoc)); + } + + if (aContent->IsElement()) { + if (RefPtr<nsPresContext> presContext = mPresContext) { + IMEStateManager::OnRemoveContent(*presContext, + MOZ_KnownLive(*aContent->AsElement())); + } + WheelTransaction::OnRemoveElement(aContent); + } + + // inform the focus manager that the content is being removed. If this + // content is focused, the focus will be removed without firing events. + if (RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager()) { + fm->ContentRemoved(aDocument, aContent); + } + + RemoveNodeFromChainIfNeeded(ElementState::HOVER, aContent, true); + RemoveNodeFromChainIfNeeded(ElementState::ACTIVE, aContent, true); + + if (sDragOverContent && + sDragOverContent->OwnerDoc() == aContent->OwnerDoc() && + nsContentUtils::ContentIsFlattenedTreeDescendantOf(sDragOverContent, + aContent)) { + sDragOverContent = nullptr; + } + + PointerEventHandler::ReleaseIfCaptureByDescendant(aContent); + + if (mMouseEnterLeaveHelper) { + const bool hadMouseOutTarget = + mMouseEnterLeaveHelper->GetOutEventTarget() != nullptr; + mMouseEnterLeaveHelper->ContentRemoved(*aContent); + // If we lose the mouseout target, we need to dispatch mouseover on an + // ancestor. For ensuring the chance to do it before next user input, we + // need a synthetic mouse move. + if (hadMouseOutTarget && !mMouseEnterLeaveHelper->GetOutEventTarget()) { + if (PresShell* presShell = + mPresContext ? mPresContext->GetPresShell() : nullptr) { + presShell->SynthesizeMouseMove(false); + } + } + } + for (const auto& entry : mPointersEnterLeaveHelper) { + if (entry.GetData()) { + entry.GetData()->ContentRemoved(*aContent); + } + } +} + +void EventStateManager::TextControlRootWillBeRemoved( + TextControlElement& aTextControlElement) { + if (!mGestureDownInTextControl || !mGestureDownFrameOwner || + !mGestureDownFrameOwner->IsInNativeAnonymousSubtree()) { + return; + } + // If we track gesture to start drag in aTextControlElement, we should keep + // tracking it with aTextContrlElement itself for now because this may be + // caused by reframing aTextControlElement which may not be intended by the + // user. + if (&aTextControlElement == + mGestureDownFrameOwner + ->GetClosestNativeAnonymousSubtreeRootParentOrHost()) { + mGestureDownFrameOwner = &aTextControlElement; + } +} + +void EventStateManager::TextControlRootAdded( + Element& aAnonymousDivElement, TextControlElement& aTextControlElement) { + if (!mGestureDownInTextControl || + mGestureDownFrameOwner != &aTextControlElement) { + return; + } + // If we track gesture to start drag in aTextControlElement, but the frame + // owner is the text control element itself, the anonymous nodes in it are + // recreated by a reframe. If so, we should keep tracking it with the + // recreated native anonymous node. + mGestureDownFrameOwner = + aAnonymousDivElement.GetFirstChild() + ? aAnonymousDivElement.GetFirstChild() + : static_cast<nsIContent*>(&aAnonymousDivElement); +} + +bool EventStateManager::EventStatusOK(WidgetGUIEvent* aEvent) { + return !(aEvent->mMessage == eMouseDown && + aEvent->AsMouseEvent()->mButton == MouseButton::ePrimary && + !sNormalLMouseEventInProcess); +} + +//------------------------------------------- +// Access Key Registration +//------------------------------------------- +void EventStateManager::RegisterAccessKey(Element* aElement, uint32_t aKey) { + if (aElement && !mAccessKeys.Contains(aElement)) { + mAccessKeys.AppendObject(aElement); + } +} + +void EventStateManager::UnregisterAccessKey(Element* aElement, uint32_t aKey) { + if (aElement) { + mAccessKeys.RemoveObject(aElement); + } +} + +uint32_t EventStateManager::GetRegisteredAccessKey(Element* aElement) { + MOZ_ASSERT(aElement); + + if (!mAccessKeys.Contains(aElement)) { + return 0; + } + + nsAutoString accessKey; + aElement->GetAttr(nsGkAtoms::accesskey, accessKey); + return accessKey.First(); +} + +void EventStateManager::EnsureDocument(nsPresContext* aPresContext) { + if (!mDocument) mDocument = aPresContext->Document(); +} + +void EventStateManager::FlushLayout(nsPresContext* aPresContext) { + MOZ_ASSERT(aPresContext, "nullptr ptr"); + if (RefPtr<PresShell> presShell = aPresContext->GetPresShell()) { + presShell->FlushPendingNotifications(FlushType::InterruptibleLayout); + } +} + +Element* EventStateManager::GetFocusedElement() { + nsFocusManager* fm = nsFocusManager::GetFocusManager(); + EnsureDocument(mPresContext); + if (!fm || !mDocument) { + return nullptr; + } + + nsCOMPtr<nsPIDOMWindowOuter> focusedWindow; + return nsFocusManager::GetFocusedDescendant( + mDocument->GetWindow(), nsFocusManager::eOnlyCurrentWindow, + getter_AddRefs(focusedWindow)); +} + +//------------------------------------------------------- +// Return true if the docshell is visible + +bool EventStateManager::IsShellVisible(nsIDocShell* aShell) { + NS_ASSERTION(aShell, "docshell is null"); + + nsCOMPtr<nsIBaseWindow> basewin = do_QueryInterface(aShell); + if (!basewin) return true; + + bool isVisible = true; + basewin->GetVisibility(&isVisible); + + // We should be doing some additional checks here so that + // we don't tab into hidden tabs of tabbrowser. -bryner + + return isVisible; +} + +nsresult EventStateManager::DoContentCommandEvent( + WidgetContentCommandEvent* aEvent) { + EnsureDocument(mPresContext); + NS_ENSURE_TRUE(mDocument, NS_ERROR_FAILURE); + nsCOMPtr<nsPIDOMWindowOuter> window(mDocument->GetWindow()); + NS_ENSURE_TRUE(window, NS_ERROR_FAILURE); + + nsCOMPtr<nsPIWindowRoot> root = window->GetTopWindowRoot(); + NS_ENSURE_TRUE(root, NS_ERROR_FAILURE); + const char* cmd; + switch (aEvent->mMessage) { + case eContentCommandCut: + cmd = "cmd_cut"; + break; + case eContentCommandCopy: + cmd = "cmd_copy"; + break; + case eContentCommandPaste: + cmd = "cmd_paste"; + break; + case eContentCommandDelete: + cmd = "cmd_delete"; + break; + case eContentCommandUndo: + cmd = "cmd_undo"; + break; + case eContentCommandRedo: + cmd = "cmd_redo"; + break; + case eContentCommandPasteTransferable: + cmd = "cmd_pasteTransferable"; + break; + case eContentCommandLookUpDictionary: + cmd = "cmd_lookUpDictionary"; + break; + default: + return NS_ERROR_NOT_IMPLEMENTED; + } + // If user tries to do something, user must try to do it in visible window. + // So, let's retrieve controller of visible window. + nsCOMPtr<nsIController> controller; + nsresult rv = + root->GetControllerForCommand(cmd, true, getter_AddRefs(controller)); + NS_ENSURE_SUCCESS(rv, rv); + if (!controller) { + // When GetControllerForCommand succeeded but there is no controller, the + // command isn't supported. + aEvent->mIsEnabled = false; + } else { + bool canDoIt; + rv = controller->IsCommandEnabled(cmd, &canDoIt); + NS_ENSURE_SUCCESS(rv, rv); + aEvent->mIsEnabled = canDoIt; + if (canDoIt && !aEvent->mOnlyEnabledCheck) { + switch (aEvent->mMessage) { + case eContentCommandPasteTransferable: { + BrowserParent* remote = BrowserParent::GetFocused(); + if (remote) { + IPCTransferable ipcTransferable; + nsContentUtils::TransferableToIPCTransferable( + aEvent->mTransferable, &ipcTransferable, false, + remote->Manager()); + remote->SendPasteTransferable(std::move(ipcTransferable)); + rv = NS_OK; + } else { + nsCOMPtr<nsICommandController> commandController = + do_QueryInterface(controller); + NS_ENSURE_STATE(commandController); + + RefPtr<nsCommandParams> params = new nsCommandParams(); + rv = params->SetISupports("transferable", aEvent->mTransferable); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + rv = commandController->DoCommandWithParams(cmd, params); + } + break; + } + + case eContentCommandLookUpDictionary: { + nsCOMPtr<nsICommandController> commandController = + do_QueryInterface(controller); + if (NS_WARN_IF(!commandController)) { + return NS_ERROR_FAILURE; + } + + RefPtr<nsCommandParams> params = new nsCommandParams(); + rv = params->SetInt("x", aEvent->mRefPoint.x); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + rv = params->SetInt("y", aEvent->mRefPoint.y); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + rv = commandController->DoCommandWithParams(cmd, params); + break; + } + + default: + rv = controller->DoCommand(cmd); + break; + } + NS_ENSURE_SUCCESS(rv, rv); + } + } + aEvent->mSucceeded = true; + return NS_OK; +} + +nsresult EventStateManager::DoContentCommandInsertTextEvent( + WidgetContentCommandEvent* aEvent) { + MOZ_ASSERT(aEvent); + MOZ_ASSERT(aEvent->mMessage == eContentCommandInsertText); + MOZ_DIAGNOSTIC_ASSERT(aEvent->mString.isSome()); + MOZ_DIAGNOSTIC_ASSERT(!aEvent->mString.ref().IsEmpty()); + + aEvent->mIsEnabled = false; + aEvent->mSucceeded = false; + + NS_ENSURE_TRUE(mPresContext, NS_ERROR_NOT_AVAILABLE); + + if (XRE_IsParentProcess()) { + // Handle it in focused content process if there is. + if (BrowserParent* remote = BrowserParent::GetFocused()) { + remote->SendInsertText(aEvent->mString.ref()); + aEvent->mIsEnabled = true; // XXX it can be a lie... + aEvent->mSucceeded = true; + return NS_OK; + } + } + + // If there is no active editor in this process, we should treat the command + // is disabled. + RefPtr<EditorBase> activeEditor = + nsContentUtils::GetActiveEditor(mPresContext); + if (!activeEditor) { + aEvent->mSucceeded = true; + return NS_OK; + } + + nsresult rv = activeEditor->InsertTextAsAction(aEvent->mString.ref()); + aEvent->mIsEnabled = rv != NS_SUCCESS_DOM_NO_OPERATION; + aEvent->mSucceeded = NS_SUCCEEDED(rv); + return NS_OK; +} + +nsresult EventStateManager::DoContentCommandScrollEvent( + WidgetContentCommandEvent* aEvent) { + NS_ENSURE_TRUE(mPresContext, NS_ERROR_NOT_AVAILABLE); + PresShell* presShell = mPresContext->GetPresShell(); + NS_ENSURE_TRUE(presShell, NS_ERROR_NOT_AVAILABLE); + NS_ENSURE_TRUE(aEvent->mScroll.mAmount != 0, NS_ERROR_INVALID_ARG); + + ScrollUnit scrollUnit; + switch (aEvent->mScroll.mUnit) { + case WidgetContentCommandEvent::eCmdScrollUnit_Line: + scrollUnit = ScrollUnit::LINES; + break; + case WidgetContentCommandEvent::eCmdScrollUnit_Page: + scrollUnit = ScrollUnit::PAGES; + break; + case WidgetContentCommandEvent::eCmdScrollUnit_Whole: + scrollUnit = ScrollUnit::WHOLE; + break; + default: + return NS_ERROR_INVALID_ARG; + } + + aEvent->mSucceeded = true; + + nsIScrollableFrame* sf = + presShell->GetScrollableFrameToScroll(layers::EitherScrollDirection); + aEvent->mIsEnabled = + sf ? (aEvent->mScroll.mIsHorizontal ? WheelHandlingUtils::CanScrollOn( + sf, aEvent->mScroll.mAmount, 0) + : WheelHandlingUtils::CanScrollOn( + sf, 0, aEvent->mScroll.mAmount)) + : false; + + if (!aEvent->mIsEnabled || aEvent->mOnlyEnabledCheck) { + return NS_OK; + } + + nsIntPoint pt(0, 0); + if (aEvent->mScroll.mIsHorizontal) { + pt.x = aEvent->mScroll.mAmount; + } else { + pt.y = aEvent->mScroll.mAmount; + } + + // The caller may want synchronous scrolling. + sf->ScrollBy(pt, scrollUnit, ScrollMode::Instant); + return NS_OK; +} + +void EventStateManager::SetActiveManager(EventStateManager* aNewESM, + nsIContent* aContent) { + if (sActiveESM && aNewESM != sActiveESM) { + sActiveESM->SetContentState(nullptr, ElementState::ACTIVE); + } + sActiveESM = aNewESM; + if (sActiveESM && aContent) { + sActiveESM->SetContentState(aContent, ElementState::ACTIVE); + } +} + +void EventStateManager::ClearGlobalActiveContent(EventStateManager* aClearer) { + if (aClearer) { + aClearer->SetContentState(nullptr, ElementState::ACTIVE); + if (sDragOverContent) { + aClearer->SetContentState(nullptr, ElementState::DRAGOVER); + } + } + if (sActiveESM && aClearer != sActiveESM) { + sActiveESM->SetContentState(nullptr, ElementState::ACTIVE); + } + sActiveESM = nullptr; +} + +/******************************************************************/ +/* mozilla::EventStateManager::DeltaAccumulator */ +/******************************************************************/ + +void EventStateManager::DeltaAccumulator::InitLineOrPageDelta( + nsIFrame* aTargetFrame, EventStateManager* aESM, WidgetWheelEvent* aEvent) { + MOZ_ASSERT(aESM); + MOZ_ASSERT(aEvent); + + // Reset if the previous wheel event is too old. + if (!mLastTime.IsNull()) { + TimeDuration duration = TimeStamp::Now() - mLastTime; + if (duration.ToMilliseconds() > + StaticPrefs::mousewheel_transaction_timeout()) { + Reset(); + } + } + // If we have accumulated delta, we may need to reset it. + if (IsInTransaction()) { + // If wheel event type is changed, reset the values. + if (mHandlingDeltaMode != aEvent->mDeltaMode || + mIsNoLineOrPageDeltaDevice != aEvent->mIsNoLineOrPageDelta) { + Reset(); + } else { + // If the delta direction is changed, we should reset only the + // accumulated values. + if (mX && aEvent->mDeltaX && ((aEvent->mDeltaX > 0.0) != (mX > 0.0))) { + mX = mPendingScrollAmountX = 0.0; + } + if (mY && aEvent->mDeltaY && ((aEvent->mDeltaY > 0.0) != (mY > 0.0))) { + mY = mPendingScrollAmountY = 0.0; + } + } + } + + mHandlingDeltaMode = aEvent->mDeltaMode; + mIsNoLineOrPageDeltaDevice = aEvent->mIsNoLineOrPageDelta; + + { + nsIFrame* frame = aESM->ComputeScrollTarget(aTargetFrame, aEvent, + COMPUTE_DEFAULT_ACTION_TARGET); + nsPresContext* pc = + frame ? frame->PresContext() : aTargetFrame->PresContext(); + nsIScrollableFrame* scrollTarget = do_QueryFrame(frame); + aEvent->mScrollAmount = aESM->GetScrollAmount(pc, aEvent, scrollTarget); + } + + // If it's handling neither a device that does not provide line or page deltas + // nor delta values multiplied by prefs, we must not modify lineOrPageDelta + // values. + // TODO(emilio): Does this care about overridden scroll speed? + if (!mIsNoLineOrPageDeltaDevice && + !EventStateManager::WheelPrefs::GetInstance() + ->NeedToComputeLineOrPageDelta(aEvent)) { + // Set the delta values to mX and mY. They would be used when above block + // resets mX/mY/mPendingScrollAmountX/mPendingScrollAmountY if the direction + // is changed. + // NOTE: We shouldn't accumulate the delta values, it might could cause + // overflow even though it's not a realistic situation. + if (aEvent->mDeltaX) { + mX = aEvent->mDeltaX; + } + if (aEvent->mDeltaY) { + mY = aEvent->mDeltaY; + } + mLastTime = TimeStamp::Now(); + return; + } + + mX += aEvent->mDeltaX; + mY += aEvent->mDeltaY; + + if (mHandlingDeltaMode == WheelEvent_Binding::DOM_DELTA_PIXEL) { + // Records pixel delta values and init mLineOrPageDeltaX and + // mLineOrPageDeltaY for wheel events which are caused by pixel only + // devices. Ignore mouse wheel transaction for computing this. The + // lineOrPageDelta values will be used by dispatching legacy + // eMouseScrollEventClass (DOMMouseScroll) but not be used for scrolling + // of default action. The transaction should be used only for the default + // action. + auto scrollAmountInCSSPixels = + CSSIntSize::FromAppUnitsRounded(aEvent->mScrollAmount); + + aEvent->mLineOrPageDeltaX = RoundDown(mX) / scrollAmountInCSSPixels.width; + aEvent->mLineOrPageDeltaY = RoundDown(mY) / scrollAmountInCSSPixels.height; + + mX -= aEvent->mLineOrPageDeltaX * scrollAmountInCSSPixels.width; + mY -= aEvent->mLineOrPageDeltaY * scrollAmountInCSSPixels.height; + } else { + aEvent->mLineOrPageDeltaX = RoundDown(mX); + aEvent->mLineOrPageDeltaY = RoundDown(mY); + mX -= aEvent->mLineOrPageDeltaX; + mY -= aEvent->mLineOrPageDeltaY; + } + + mLastTime = TimeStamp::Now(); +} + +void EventStateManager::DeltaAccumulator::Reset() { + mX = mY = 0.0; + mPendingScrollAmountX = mPendingScrollAmountY = 0.0; + mHandlingDeltaMode = UINT32_MAX; + mIsNoLineOrPageDeltaDevice = false; +} + +nsIntPoint +EventStateManager::DeltaAccumulator::ComputeScrollAmountForDefaultAction( + WidgetWheelEvent* aEvent, const nsIntSize& aScrollAmountInDevPixels) { + MOZ_ASSERT(aEvent); + + DeltaValues acceleratedDelta = WheelTransaction::AccelerateWheelDelta(aEvent); + + nsIntPoint result(0, 0); + if (aEvent->mDeltaMode == WheelEvent_Binding::DOM_DELTA_PIXEL) { + mPendingScrollAmountX += acceleratedDelta.deltaX; + mPendingScrollAmountY += acceleratedDelta.deltaY; + } else { + mPendingScrollAmountX += + aScrollAmountInDevPixels.width * acceleratedDelta.deltaX; + mPendingScrollAmountY += + aScrollAmountInDevPixels.height * acceleratedDelta.deltaY; + } + result.x = RoundDown(mPendingScrollAmountX); + result.y = RoundDown(mPendingScrollAmountY); + mPendingScrollAmountX -= result.x; + mPendingScrollAmountY -= result.y; + + return result; +} + +/******************************************************************/ +/* mozilla::EventStateManager::WheelPrefs */ +/******************************************************************/ + +// static +EventStateManager::WheelPrefs* EventStateManager::WheelPrefs::GetInstance() { + if (!sInstance) { + sInstance = new WheelPrefs(); + } + return sInstance; +} + +// static +void EventStateManager::WheelPrefs::Shutdown() { + delete sInstance; + sInstance = nullptr; +} + +// static +void EventStateManager::WheelPrefs::OnPrefChanged(const char* aPrefName, + void* aClosure) { + // forget all prefs, it's not problem for performance. + sInstance->Reset(); + DeltaAccumulator::GetInstance()->Reset(); +} + +EventStateManager::WheelPrefs::WheelPrefs() { + Reset(); + Preferences::RegisterPrefixCallback(OnPrefChanged, "mousewheel."); +} + +EventStateManager::WheelPrefs::~WheelPrefs() { + Preferences::UnregisterPrefixCallback(OnPrefChanged, "mousewheel."); +} + +void EventStateManager::WheelPrefs::Reset() { memset(mInit, 0, sizeof(mInit)); } + +EventStateManager::WheelPrefs::Index EventStateManager::WheelPrefs::GetIndexFor( + const WidgetWheelEvent* aEvent) { + if (!aEvent) { + return INDEX_DEFAULT; + } + + Modifiers modifiers = (aEvent->mModifiers & (MODIFIER_ALT | MODIFIER_CONTROL | + MODIFIER_META | MODIFIER_SHIFT)); + + switch (modifiers) { + case MODIFIER_ALT: + return INDEX_ALT; + case MODIFIER_CONTROL: + return INDEX_CONTROL; + case MODIFIER_META: + return INDEX_META; + case MODIFIER_SHIFT: + return INDEX_SHIFT; + default: + // If two or more modifier keys are pressed, we should use default + // settings. + return INDEX_DEFAULT; + } +} + +void EventStateManager::WheelPrefs::GetBasePrefName( + EventStateManager::WheelPrefs::Index aIndex, nsACString& aBasePrefName) { + aBasePrefName.AssignLiteral("mousewheel."); + switch (aIndex) { + case INDEX_ALT: + aBasePrefName.AppendLiteral("with_alt."); + break; + case INDEX_CONTROL: + aBasePrefName.AppendLiteral("with_control."); + break; + case INDEX_META: + aBasePrefName.AppendLiteral("with_meta."); + break; + case INDEX_SHIFT: + aBasePrefName.AppendLiteral("with_shift."); + break; + case INDEX_DEFAULT: + default: + aBasePrefName.AppendLiteral("default."); + break; + } +} + +void EventStateManager::WheelPrefs::Init( + EventStateManager::WheelPrefs::Index aIndex) { + if (mInit[aIndex]) { + return; + } + mInit[aIndex] = true; + + nsAutoCString basePrefName; + GetBasePrefName(aIndex, basePrefName); + + nsAutoCString prefNameX(basePrefName); + prefNameX.AppendLiteral("delta_multiplier_x"); + mMultiplierX[aIndex] = + static_cast<double>(Preferences::GetInt(prefNameX.get(), 100)) / 100; + + nsAutoCString prefNameY(basePrefName); + prefNameY.AppendLiteral("delta_multiplier_y"); + mMultiplierY[aIndex] = + static_cast<double>(Preferences::GetInt(prefNameY.get(), 100)) / 100; + + nsAutoCString prefNameZ(basePrefName); + prefNameZ.AppendLiteral("delta_multiplier_z"); + mMultiplierZ[aIndex] = + static_cast<double>(Preferences::GetInt(prefNameZ.get(), 100)) / 100; + + nsAutoCString prefNameAction(basePrefName); + prefNameAction.AppendLiteral("action"); + int32_t action = Preferences::GetInt(prefNameAction.get(), ACTION_SCROLL); + if (action < int32_t(ACTION_NONE) || action > int32_t(ACTION_LAST)) { + NS_WARNING("Unsupported action pref value, replaced with 'Scroll'."); + action = ACTION_SCROLL; + } + mActions[aIndex] = static_cast<Action>(action); + + // Compute action values overridden by .override_x pref. + // At present, override is possible only for the x-direction + // because this pref is introduced mainly for tilt wheels. + // Note that ACTION_HORIZONTALIZED_SCROLL isn't a valid value for this pref + // because it affects only to deltaY. + prefNameAction.AppendLiteral(".override_x"); + int32_t actionOverrideX = Preferences::GetInt(prefNameAction.get(), -1); + if (actionOverrideX < -1 || actionOverrideX > int32_t(ACTION_LAST) || + actionOverrideX == ACTION_HORIZONTALIZED_SCROLL) { + NS_WARNING("Unsupported action override pref value, didn't override."); + actionOverrideX = -1; + } + mOverriddenActionsX[aIndex] = (actionOverrideX == -1) + ? static_cast<Action>(action) + : static_cast<Action>(actionOverrideX); +} + +void EventStateManager::WheelPrefs::GetMultiplierForDeltaXAndY( + const WidgetWheelEvent* aEvent, Index aIndex, double* aMultiplierForDeltaX, + double* aMultiplierForDeltaY) { + *aMultiplierForDeltaX = mMultiplierX[aIndex]; + *aMultiplierForDeltaY = mMultiplierY[aIndex]; + // If the event has been horizontalized(I.e. treated as a horizontal wheel + // scroll for a vertical wheel scroll), then we should swap mMultiplierX and + // mMultiplierY. By doing this, multipliers will still apply to the delta + // values they origianlly corresponded to. + if (aEvent->mDeltaValuesHorizontalizedForDefaultHandler && + ComputeActionFor(aEvent) == ACTION_HORIZONTALIZED_SCROLL) { + std::swap(*aMultiplierForDeltaX, *aMultiplierForDeltaY); + } +} + +void EventStateManager::WheelPrefs::ApplyUserPrefsToDelta( + WidgetWheelEvent* aEvent) { + if (aEvent->mCustomizedByUserPrefs) { + return; + } + + Index index = GetIndexFor(aEvent); + Init(index); + + double multiplierForDeltaX = 1.0, multiplierForDeltaY = 1.0; + GetMultiplierForDeltaXAndY(aEvent, index, &multiplierForDeltaX, + &multiplierForDeltaY); + aEvent->mDeltaX *= multiplierForDeltaX; + aEvent->mDeltaY *= multiplierForDeltaY; + aEvent->mDeltaZ *= mMultiplierZ[index]; + + // If the multiplier is 1.0 or -1.0, i.e., it doesn't change the absolute + // value, we should use lineOrPageDelta values which were set by widget. + // Otherwise, we need to compute them from accumulated delta values. + if (!NeedToComputeLineOrPageDelta(aEvent)) { + aEvent->mLineOrPageDeltaX *= static_cast<int32_t>(multiplierForDeltaX); + aEvent->mLineOrPageDeltaY *= static_cast<int32_t>(multiplierForDeltaY); + } else { + aEvent->mLineOrPageDeltaX = 0; + aEvent->mLineOrPageDeltaY = 0; + } + + aEvent->mCustomizedByUserPrefs = + ((mMultiplierX[index] != 1.0) || (mMultiplierY[index] != 1.0) || + (mMultiplierZ[index] != 1.0)); +} + +void EventStateManager::WheelPrefs::CancelApplyingUserPrefsFromOverflowDelta( + WidgetWheelEvent* aEvent) { + Index index = GetIndexFor(aEvent); + Init(index); + + // XXX If the multiplier pref value is negative, the scroll direction was + // changed and caused to scroll different direction. In such case, + // this method reverts the sign of overflowDelta. Does it make widget + // happy? Although, widget can know the pref applied delta values by + // referrencing the deltaX and deltaY of the event. + + double multiplierForDeltaX = 1.0, multiplierForDeltaY = 1.0; + GetMultiplierForDeltaXAndY(aEvent, index, &multiplierForDeltaX, + &multiplierForDeltaY); + if (multiplierForDeltaX) { + aEvent->mOverflowDeltaX /= multiplierForDeltaX; + } + if (multiplierForDeltaY) { + aEvent->mOverflowDeltaY /= multiplierForDeltaY; + } +} + +EventStateManager::WheelPrefs::Action +EventStateManager::WheelPrefs::ComputeActionFor( + const WidgetWheelEvent* aEvent) { + Index index = GetIndexFor(aEvent); + Init(index); + + bool deltaXPreferred = (Abs(aEvent->mDeltaX) > Abs(aEvent->mDeltaY) && + Abs(aEvent->mDeltaX) > Abs(aEvent->mDeltaZ)); + Action* actions = deltaXPreferred ? mOverriddenActionsX : mActions; + if (actions[index] == ACTION_NONE || actions[index] == ACTION_SCROLL || + actions[index] == ACTION_HORIZONTALIZED_SCROLL) { + return actions[index]; + } + + // Momentum events shouldn't run special actions. + if (aEvent->mIsMomentum) { + // Use the default action. Note that user might kill the wheel scrolling. + Init(INDEX_DEFAULT); + if (actions[INDEX_DEFAULT] == ACTION_SCROLL || + actions[INDEX_DEFAULT] == ACTION_HORIZONTALIZED_SCROLL) { + return actions[INDEX_DEFAULT]; + } + return ACTION_NONE; + } + + return actions[index]; +} + +bool EventStateManager::WheelPrefs::NeedToComputeLineOrPageDelta( + const WidgetWheelEvent* aEvent) { + Index index = GetIndexFor(aEvent); + Init(index); + + return (mMultiplierX[index] != 1.0 && mMultiplierX[index] != -1.0) || + (mMultiplierY[index] != 1.0 && mMultiplierY[index] != -1.0); +} + +void EventStateManager::WheelPrefs::GetUserPrefsForEvent( + const WidgetWheelEvent* aEvent, double* aOutMultiplierX, + double* aOutMultiplierY) { + Index index = GetIndexFor(aEvent); + Init(index); + + double multiplierForDeltaX = 1.0, multiplierForDeltaY = 1.0; + GetMultiplierForDeltaXAndY(aEvent, index, &multiplierForDeltaX, + &multiplierForDeltaY); + *aOutMultiplierX = multiplierForDeltaX; + *aOutMultiplierY = multiplierForDeltaY; +} + +// static +Maybe<layers::APZWheelAction> EventStateManager::APZWheelActionFor( + const WidgetWheelEvent* aEvent) { + if (aEvent->mMessage != eWheel) { + return Nothing(); + } + WheelPrefs::Action action = + WheelPrefs::GetInstance()->ComputeActionFor(aEvent); + switch (action) { + case WheelPrefs::ACTION_SCROLL: + case WheelPrefs::ACTION_HORIZONTALIZED_SCROLL: + return Some(layers::APZWheelAction::Scroll); + case WheelPrefs::ACTION_PINCH_ZOOM: + return Some(layers::APZWheelAction::PinchZoom); + default: + return Nothing(); + } +} + +// static +WheelDeltaAdjustmentStrategy EventStateManager::GetWheelDeltaAdjustmentStrategy( + const WidgetWheelEvent& aEvent) { + if (aEvent.mMessage != eWheel) { + return WheelDeltaAdjustmentStrategy::eNone; + } + switch (WheelPrefs::GetInstance()->ComputeActionFor(&aEvent)) { + case WheelPrefs::ACTION_SCROLL: + if (StaticPrefs::mousewheel_autodir_enabled() && 0 == aEvent.mDeltaZ) { + if (StaticPrefs::mousewheel_autodir_honourroot()) { + return WheelDeltaAdjustmentStrategy::eAutoDirWithRootHonour; + } + return WheelDeltaAdjustmentStrategy::eAutoDir; + } + return WheelDeltaAdjustmentStrategy::eNone; + case WheelPrefs::ACTION_HORIZONTALIZED_SCROLL: + return WheelDeltaAdjustmentStrategy::eHorizontalize; + default: + break; + } + return WheelDeltaAdjustmentStrategy::eNone; +} + +void EventStateManager::GetUserPrefsForWheelEvent( + const WidgetWheelEvent* aEvent, double* aOutMultiplierX, + double* aOutMultiplierY) { + WheelPrefs::GetInstance()->GetUserPrefsForEvent(aEvent, aOutMultiplierX, + aOutMultiplierY); +} + +bool EventStateManager::WheelPrefs::IsOverOnePageScrollAllowedX( + const WidgetWheelEvent* aEvent) { + Index index = GetIndexFor(aEvent); + Init(index); + return Abs(mMultiplierX[index]) >= + MIN_MULTIPLIER_VALUE_ALLOWING_OVER_ONE_PAGE_SCROLL; +} + +bool EventStateManager::WheelPrefs::IsOverOnePageScrollAllowedY( + const WidgetWheelEvent* aEvent) { + Index index = GetIndexFor(aEvent); + Init(index); + return Abs(mMultiplierY[index]) >= + MIN_MULTIPLIER_VALUE_ALLOWING_OVER_ONE_PAGE_SCROLL; +} + +void OverOutElementsWrapper::ContentRemoved(nsIContent& aContent) { + if (!mDeepestEnterEventTarget) { + return; + } + + if (!nsContentUtils::ContentIsFlattenedTreeDescendantOf( + mDeepestEnterEventTarget, &aContent)) { + return; + } + + if (!StaticPrefs:: + dom_events_mouse_pointer_boundary_keep_enter_targets_after_over_target_removed()) { + mDeepestEnterEventTarget = nullptr; + return; + } + + if (mDispatchingOverEventTarget && + (mDeepestEnterEventTarget == mDispatchingOverEventTarget || + nsContentUtils::ContentIsFlattenedTreeDescendantOf( + mDispatchingOverEventTarget, &aContent))) { + if (mDispatchingOverEventTarget == + mDispatchingOutOrDeepestLeaveEventTarget) { + mDispatchingOutOrDeepestLeaveEventTarget = nullptr; + } + mDispatchingOverEventTarget = nullptr; + } + if (mDispatchingOutOrDeepestLeaveEventTarget && + (mDeepestEnterEventTarget == mDispatchingOutOrDeepestLeaveEventTarget || + nsContentUtils::ContentIsFlattenedTreeDescendantOf( + mDispatchingOutOrDeepestLeaveEventTarget, &aContent))) { + mDispatchingOutOrDeepestLeaveEventTarget = nullptr; + } + mDeepestEnterEventTarget = aContent.GetFlattenedTreeParent(); + mDeepestEnterEventTargetIsOverEventTarget = false; +} + +} // namespace mozilla |