Bug Summary

File:var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp
Warning:line 1749, column 11
Access to field 'mMessage' results in a dereference of a null pointer (loaded from variable 'mouseEvent')

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name EventStateManager.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -ffp-contract=off -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dom/events -fcoverage-compilation-dir=/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dom/events -resource-dir /usr/lib/llvm-18/lib/clang/18 -include /var/lib/jenkins/workspace/firefox-scan-build/config/gcc_hidden.h -include /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/mozilla-config.h -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/stl_wrappers -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/system_wrappers -U _FORTIFY_SOURCE -D _FORTIFY_SOURCE=2 -D DEBUG=1 -D MOZ_HAS_MOZGLUE -D MOZILLA_INTERNAL_API -D IMPL_LIBXUL -D STATIC_EXPORTABLE_JS_API -I /var/lib/jenkins/workspace/firefox-scan-build/dom/events -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dom/events -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/ipc/ipdl/_ipdlheaders -I /var/lib/jenkins/workspace/firefox-scan-build/ipc/chromium/src -I /var/lib/jenkins/workspace/firefox-scan-build/docshell/base -I /var/lib/jenkins/workspace/firefox-scan-build/dom/base -I /var/lib/jenkins/workspace/firefox-scan-build/dom/html -I /var/lib/jenkins/workspace/firefox-scan-build/dom/storage -I /var/lib/jenkins/workspace/firefox-scan-build/dom/xml -I /var/lib/jenkins/workspace/firefox-scan-build/dom/xul -I /var/lib/jenkins/workspace/firefox-scan-build/js/xpconnect/wrappers -I /var/lib/jenkins/workspace/firefox-scan-build/layout/forms -I /var/lib/jenkins/workspace/firefox-scan-build/layout/generic -I /var/lib/jenkins/workspace/firefox-scan-build/layout/xul -I /var/lib/jenkins/workspace/firefox-scan-build/layout/xul/tree -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/nspr -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/nss -D MOZILLA_CLIENT -internal-isystem /usr/bin/../lib/gcc/x86_64-linux-gnu/13/../../../../include/c++/13 -internal-isystem /usr/bin/../lib/gcc/x86_64-linux-gnu/13/../../../../include/x86_64-linux-gnu/c++/13 -internal-isystem /usr/bin/../lib/gcc/x86_64-linux-gnu/13/../../../../include/c++/13/backward -internal-isystem /usr/lib/llvm-18/lib/clang/18/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib/gcc/x86_64-linux-gnu/13/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-error=tautological-type-limit-compare -Wno-invalid-offsetof -Wno-range-loop-analysis -Wno-deprecated-anon-enum-enum-conversion -Wno-deprecated-enum-enum-conversion -Wno-deprecated-this-capture -Wno-inline-new-delete -Wno-error=deprecated-declarations -Wno-error=array-bounds -Wno-error=free-nonheap-object -Wno-error=atomic-alignment -Wno-error=deprecated-builtins -Wno-psabi -Wno-error=builtin-macro-redefined -Wno-vla-cxx-extension -Wno-unknown-warning-option -fdeprecated-macro -ferror-limit 19 -stack-protector 2 -fstack-clash-protection -ftrivial-auto-var-init=pattern -fno-rtti -fgnuc-version=4.2.1 -fno-aligned-allocation -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2024-05-14-034047-16143-1 -x c++ /var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp
1/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2/* vim: set ts=8 sts=2 et sw=2 tw=80: */
3/* This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6
7#include "EventStateManager.h"
8
9#include "mozilla/AsyncEventDispatcher.h"
10#include "mozilla/Attributes.h"
11#include "mozilla/EditorBase.h"
12#include "mozilla/EventDispatcher.h"
13#include "mozilla/EventForwards.h"
14#include "mozilla/Hal.h"
15#include "mozilla/HTMLEditor.h"
16#include "mozilla/IMEStateManager.h"
17#include "mozilla/Likely.h"
18#include "mozilla/FocusModel.h"
19#include "mozilla/MiscEvents.h"
20#include "mozilla/MathAlgorithms.h"
21#include "mozilla/MouseEvents.h"
22#include "mozilla/PointerLockManager.h"
23#include "mozilla/PresShell.h"
24#include "mozilla/ScopeExit.h"
25#include "mozilla/ScrollTypes.h"
26#include "mozilla/TextComposition.h"
27#include "mozilla/TextControlElement.h"
28#include "mozilla/TextEditor.h"
29#include "mozilla/TextEvents.h"
30#include "mozilla/TouchEvents.h"
31#include "mozilla/Telemetry.h"
32#include "mozilla/UniquePtr.h"
33#include "mozilla/dom/BrowserBridgeChild.h"
34#include "mozilla/dom/BrowsingContext.h"
35#include "mozilla/dom/CanonicalBrowsingContext.h"
36#include "mozilla/dom/ContentChild.h"
37#include "mozilla/dom/DOMIntersectionObserver.h"
38#include "mozilla/dom/DragEvent.h"
39#include "mozilla/dom/Event.h"
40#include "mozilla/dom/FrameLoaderBinding.h"
41#include "mozilla/dom/HTMLLabelElement.h"
42#include "mozilla/dom/HTMLInputElement.h"
43#include "mozilla/dom/MouseEventBinding.h"
44#include "mozilla/dom/BrowserChild.h"
45#include "mozilla/dom/PointerEventHandler.h"
46#include "mozilla/dom/UIEvent.h"
47#include "mozilla/dom/UIEventBinding.h"
48#include "mozilla/dom/UserActivation.h"
49#include "mozilla/dom/WheelEventBinding.h"
50#include "mozilla/glean/GleanMetrics.h"
51#include "mozilla/StaticPrefs_accessibility.h"
52#include "mozilla/StaticPrefs_browser.h"
53#include "mozilla/StaticPrefs_dom.h"
54#include "mozilla/StaticPrefs_layout.h"
55#include "mozilla/StaticPrefs_mousewheel.h"
56#include "mozilla/StaticPrefs_ui.h"
57#include "mozilla/StaticPrefs_zoom.h"
58
59#include "ContentEventHandler.h"
60#include "IMEContentObserver.h"
61#include "WheelHandlingHelper.h"
62#include "RemoteDragStartData.h"
63
64#include "nsCommandParams.h"
65#include "nsCOMPtr.h"
66#include "nsCopySupport.h"
67#include "nsFocusManager.h"
68#include "nsGenericHTMLElement.h"
69#include "nsIClipboard.h"
70#include "nsIContent.h"
71#include "nsIContentInlines.h"
72#include "mozilla/dom/Document.h"
73#include "nsICookieJarSettings.h"
74#include "nsIFrame.h"
75#include "nsFrameLoaderOwner.h"
76#include "nsIWidget.h"
77#include "nsLiteralString.h"
78#include "nsPresContext.h"
79#include "nsTArray.h"
80#include "nsGkAtoms.h"
81#include "nsIFormControl.h"
82#include "nsComboboxControlFrame.h"
83#include "nsIScrollableFrame.h"
84#include "nsIDOMXULControlElement.h"
85#include "nsNameSpaceManager.h"
86#include "nsIBaseWindow.h"
87#include "nsFrameSelection.h"
88#include "nsPIDOMWindow.h"
89#include "nsPIWindowRoot.h"
90#include "nsIWebNavigation.h"
91#include "nsIDocumentViewer.h"
92#include "nsFrameManager.h"
93#include "nsIBrowserChild.h"
94#include "nsMenuPopupFrame.h"
95
96#include "nsIObserverService.h"
97#include "nsIDocShell.h"
98
99#include "nsSubDocumentFrame.h"
100#include "nsLayoutUtils.h"
101#include "nsIInterfaceRequestorUtils.h"
102#include "nsUnicharUtils.h"
103#include "nsContentUtils.h"
104
105#include "imgIContainer.h"
106#include "nsIProperties.h"
107#include "nsISupportsPrimitives.h"
108
109#include "nsServiceManagerUtils.h"
110#include "nsITimer.h"
111#include "nsFontMetrics.h"
112#include "nsIDragService.h"
113#include "nsIDragSession.h"
114#include "mozilla/dom/DataTransfer.h"
115#include "nsContentAreaDragDrop.h"
116#include "nsTreeBodyFrame.h"
117#include "nsIController.h"
118#include "mozilla/Services.h"
119#include "mozilla/dom/ContentParent.h"
120#include "mozilla/dom/Record.h"
121#include "mozilla/dom/Selection.h"
122
123#include "mozilla/Preferences.h"
124#include "mozilla/LookAndFeel.h"
125#include "mozilla/ProfilerLabels.h"
126#include "Units.h"
127
128#ifdef XP_MACOSX
129# import <ApplicationServices/ApplicationServices.h>
130#endif
131
132namespace mozilla {
133
134using namespace dom;
135
136static const LayoutDeviceIntPoint kInvalidRefPoint =
137 LayoutDeviceIntPoint(-1, -1);
138
139static uint32_t gMouseOrKeyboardEventCounter = 0;
140static nsITimer* gUserInteractionTimer = nullptr;
141static nsITimerCallback* gUserInteractionTimerCallback = nullptr;
142
143static const double kCursorLoadingTimeout = 1000; // ms
144static AutoWeakFrame gLastCursorSourceFrame;
145static TimeStamp gLastCursorUpdateTime;
146static TimeStamp gTypingStartTime;
147static TimeStamp gTypingEndTime;
148static int32_t gTypingInteractionKeyPresses = 0;
149static dom::InteractionData gTypingInteraction = {};
150
151static inline int32_t RoundDown(double aDouble) {
152 return (aDouble > 0) ? static_cast<int32_t>(floor(aDouble))
153 : static_cast<int32_t>(ceil(aDouble));
154}
155
156static bool IsSelectingLink(nsIFrame* aTargetFrame) {
157 if (!aTargetFrame) {
158 return false;
159 }
160 const nsFrameSelection* frameSel = aTargetFrame->GetConstFrameSelection();
161 if (!frameSel || !frameSel->GetDragState()) {
162 return false;
163 }
164
165 if (!nsContentUtils::GetClosestLinkInFlatTree(aTargetFrame->GetContent())) {
166 return false;
167 }
168 return true;
169}
170
171static UniquePtr<WidgetMouseEvent> CreateMouseOrPointerWidgetEvent(
172 WidgetMouseEvent* aMouseEvent, EventMessage aMessage,
173 EventTarget* aRelatedTarget);
174
175/**
176 * Returns the common ancestor for mouseup purpose, given the
177 * current mouseup target and the previous mousedown target.
178 */
179static nsINode* GetCommonAncestorForMouseUp(
180 nsINode* aCurrentMouseUpTarget, nsINode* aLastMouseDownTarget,
181 Maybe<FormControlType>& aLastMouseDownInputControlType) {
182 if (!aCurrentMouseUpTarget || !aLastMouseDownTarget) {
183 return nullptr;
184 }
185
186 if (aCurrentMouseUpTarget == aLastMouseDownTarget) {
187 return aCurrentMouseUpTarget;
188 }
189
190 // Build the chain of parents
191 AutoTArray<nsINode*, 30> parents1;
192 do {
193 parents1.AppendElement(aCurrentMouseUpTarget);
194 aCurrentMouseUpTarget = aCurrentMouseUpTarget->GetFlattenedTreeParentNode();
195 } while (aCurrentMouseUpTarget);
196
197 AutoTArray<nsINode*, 30> parents2;
198 do {
199 parents2.AppendElement(aLastMouseDownTarget);
200 if (aLastMouseDownTarget == parents1.LastElement()) {
201 break;
202 }
203 aLastMouseDownTarget = aLastMouseDownTarget->GetFlattenedTreeParentNode();
204 } while (aLastMouseDownTarget);
205
206 // Find where the parent chain differs
207 uint32_t pos1 = parents1.Length();
208 uint32_t pos2 = parents2.Length();
209 nsINode* parent = nullptr;
210 for (uint32_t len = std::min(pos1, pos2); len > 0; --len) {
211 nsINode* child1 = parents1.ElementAt(--pos1);
212 nsINode* child2 = parents2.ElementAt(--pos2);
213 if (child1 != child2) {
214 break;
215 }
216
217 // If the input control type is different between mouseup and mousedown,
218 // this is not a valid click.
219 if (HTMLInputElement* input = HTMLInputElement::FromNodeOrNull(child1)) {
220 if (aLastMouseDownInputControlType.isSome() &&
221 aLastMouseDownInputControlType.ref() != input->ControlType()) {
222 break;
223 }
224 }
225 parent = child1;
226 }
227
228 return parent;
229}
230
231LazyLogModule sMouseBoundaryLog("MouseBoundaryEvents");
232LazyLogModule sPointerBoundaryLog("PointerBoundaryEvents");
233
234/******************************************************************/
235/* mozilla::UITimerCallback */
236/******************************************************************/
237
238class UITimerCallback final : public nsITimerCallback, public nsINamed {
239 public:
240 UITimerCallback() : mPreviousCount(0) {}
241 NS_DECL_ISUPPORTSpublic: virtual nsresult QueryInterface(const nsIID& aIID
, void** aInstancePtr) override; virtual MozExternalRefCountType
AddRef(void) override; virtual MozExternalRefCountType Release
(void) override; using HasThreadSafeRefCnt = std::false_type;
protected: nsAutoRefCnt mRefCnt; nsAutoOwningThread _mOwningThread
; public:
242 NS_DECL_NSITIMERCALLBACKvirtual nsresult Notify(nsITimer *timer) override; inline void
_ensure_GetName_exists(void) { static_assert(std::is_convertible
<decltype(this), nsINamed*>::value, "nsITimerCallback implementations must also implement nsINamed"
); }
243 NS_DECL_NSINAMEDvirtual nsresult GetName(nsACString& aName) override;
244 private:
245 ~UITimerCallback() = default;
246 uint32_t mPreviousCount;
247};
248
249NS_IMPL_ISUPPORTS(UITimerCallback, nsITimerCallback, nsINamed)MozExternalRefCountType UITimerCallback::AddRef(void) { static_assert
(!std::is_destructible_v<UITimerCallback>, "Reference-counted class "
"UITimerCallback" " should not have a public destructor. " "Make this class's destructor non-public"
); do { static_assert( mozilla::detail::AssertionConditionType
<decltype(int32_t(mRefCnt) >= 0)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(int32_t(mRefCnt) >= 0))),
0))) { do { } while (false); MOZ_ReportAssertionFailure("int32_t(mRefCnt) >= 0"
" (" "illegal refcnt" ")", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 249); AnnotateMozCrashReason("MOZ_ASSERT" "(" "int32_t(mRefCnt) >= 0"
") (" "illegal refcnt" ")"); do { *((volatile int*)__null) =
249; __attribute__((nomerge)) ::abort(); } while (false); } }
while (false); do { static_assert( mozilla::detail::AssertionConditionType
<decltype("UITimerCallback" != nullptr)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!("UITimerCallback" != nullptr
))), 0))) { do { } while (false); MOZ_ReportAssertionFailure(
"\"UITimerCallback\" != nullptr" " (" "Must specify a name" ")"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 249); AnnotateMozCrashReason("MOZ_ASSERT" "(" "\"UITimerCallback\" != nullptr"
") (" "Must specify a name" ")"); do { *((volatile int*)__null
) = 249; __attribute__((nomerge)) ::abort(); } while (false);
} } while (false); if (!mRefCnt.isThreadSafe) _mOwningThread
.AssertOwnership("UITimerCallback" " not thread-safe"); nsrefcnt
count = ++mRefCnt; NS_LogAddRef((this), (count), ("UITimerCallback"
), (uint32_t)(sizeof(*this))); return count; } MozExternalRefCountType
UITimerCallback::Release(void) { do { static_assert( mozilla
::detail::AssertionConditionType<decltype(int32_t(mRefCnt)
> 0)>::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(int32_t(mRefCnt) > 0))), 0))) { do { } while (false
); MOZ_ReportAssertionFailure("int32_t(mRefCnt) > 0" " (" "dup release"
")", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 249); AnnotateMozCrashReason("MOZ_ASSERT" "(" "int32_t(mRefCnt) > 0"
") (" "dup release" ")"); do { *((volatile int*)__null) = 249
; __attribute__((nomerge)) ::abort(); } while (false); } } while
(false); do { static_assert( mozilla::detail::AssertionConditionType
<decltype("UITimerCallback" != nullptr)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!("UITimerCallback" != nullptr
))), 0))) { do { } while (false); MOZ_ReportAssertionFailure(
"\"UITimerCallback\" != nullptr" " (" "Must specify a name" ")"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 249); AnnotateMozCrashReason("MOZ_ASSERT" "(" "\"UITimerCallback\" != nullptr"
") (" "Must specify a name" ")"); do { *((volatile int*)__null
) = 249; __attribute__((nomerge)) ::abort(); } while (false);
} } while (false); if (!mRefCnt.isThreadSafe) _mOwningThread
.AssertOwnership("UITimerCallback" " not thread-safe"); const
char* const nametmp = "UITimerCallback"; nsrefcnt count = --
mRefCnt; NS_LogRelease((this), (count), (nametmp)); if (count
== 0) { mRefCnt = 1; delete (this); return 0; } return count
; } nsresult UITimerCallback::QueryInterface(const nsIID&
aIID, void** aInstancePtr) { do { if (!(aInstancePtr)) { NS_DebugBreak
(NS_DEBUG_ASSERTION, "QueryInterface requires a non-NULL destination!"
, "aInstancePtr", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 249); MOZ_PretendNoReturn(); } } while (0); nsresult rv = NS_ERROR_FAILURE
; static_assert(2 > 0, "Need more arguments to NS_INTERFACE_TABLE"
); static const QITableEntry table[] = { {&mozilla::detail
::kImplementedIID<UITimerCallback, nsITimerCallback>, int32_t
( reinterpret_cast<char*>(static_cast<nsITimerCallback
*>((UITimerCallback*)0x1000)) - reinterpret_cast<char*>
((UITimerCallback*)0x1000))}, {&mozilla::detail::kImplementedIID
<UITimerCallback, nsINamed>, int32_t( reinterpret_cast<
char*>(static_cast<nsINamed*>((UITimerCallback*)0x1000
)) - reinterpret_cast<char*>((UITimerCallback*)0x1000))
}, {&mozilla::detail::kImplementedIID<UITimerCallback,
nsISupports>, int32_t(reinterpret_cast<char*>(static_cast
<nsISupports*>( static_cast<nsITimerCallback*>((UITimerCallback
*)0x1000))) - reinterpret_cast<char*>((UITimerCallback*
)0x1000))}, { nullptr, 0 } } ; static_assert((sizeof(table) /
sizeof(table[0])) > 1, "need at least 1 interface"); rv =
NS_TableDrivenQI(static_cast<void*>(this), aIID, aInstancePtr
, table); return rv; }
250
251// If aTimer is nullptr, this method always sends "user-interaction-inactive"
252// notification.
253NS_IMETHODIMPnsresult
254UITimerCallback::Notify(nsITimer* aTimer) {
255 nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
256 if (!obs) return NS_ERROR_FAILURE;
257 if ((gMouseOrKeyboardEventCounter == mPreviousCount) || !aTimer) {
258 gMouseOrKeyboardEventCounter = 0;
259 obs->NotifyObservers(nullptr, "user-interaction-inactive", nullptr);
260 if (gUserInteractionTimer) {
261 gUserInteractionTimer->Cancel();
262 NS_RELEASE(gUserInteractionTimer)do { (gUserInteractionTimer)->Release(); (gUserInteractionTimer
) = 0; } while (0)
;
263 }
264 } else {
265 obs->NotifyObservers(nullptr, "user-interaction-active", nullptr);
266 EventStateManager::UpdateUserActivityTimer();
267
268 if (XRE_IsParentProcess()) {
269 hal::BatteryInformation batteryInfo;
270 hal::GetCurrentBatteryInformation(&batteryInfo);
271 glean::power_battery::percentage_when_user_active.AccumulateSingleSample(
272 uint64_t(batteryInfo.level() * 100));
273 }
274 }
275 mPreviousCount = gMouseOrKeyboardEventCounter;
276 return NS_OK;
277}
278
279NS_IMETHODIMPnsresult
280UITimerCallback::GetName(nsACString& aName) {
281 aName.AssignLiteral("UITimerCallback_timer");
282 return NS_OK;
283}
284
285/******************************************************************/
286/* mozilla::OverOutElementsWrapper */
287/******************************************************************/
288
289NS_IMPL_CYCLE_COLLECTION(OverOutElementsWrapper, mDeepestEnterEventTarget,OverOutElementsWrapper::cycleCollection OverOutElementsWrapper
::_cycleCollectorGlobal; void OverOutElementsWrapper::cycleCollection
::Unlink(void* p) { OverOutElementsWrapper* tmp = DowncastCCParticipant
<OverOutElementsWrapper>(p); ImplCycleCollectionUnlink(
tmp->mDeepestEnterEventTarget); ImplCycleCollectionUnlink(
tmp->mDispatchingOverEventTarget); ImplCycleCollectionUnlink
(tmp->mDispatchingOutOrDeepestLeaveEventTarget); (void)tmp
; } nsresult OverOutElementsWrapper::cycleCollection::TraverseNative
( void* p, nsCycleCollectionTraversalCallback& cb) { OverOutElementsWrapper
* tmp = DowncastCCParticipant<OverOutElementsWrapper>(p
); cb.DescribeRefCountedNode(tmp->mRefCnt.get(), "OverOutElementsWrapper"
); ImplCycleCollectionTraverse(cb, tmp->mDeepestEnterEventTarget
, "mDeepestEnterEventTarget", 0); ImplCycleCollectionTraverse
(cb, tmp->mDispatchingOverEventTarget, "mDispatchingOverEventTarget"
, 0); ImplCycleCollectionTraverse(cb, tmp->mDispatchingOutOrDeepestLeaveEventTarget
, "mDispatchingOutOrDeepestLeaveEventTarget", 0); (void)tmp; return
NS_OK; }
290 mDispatchingOverEventTarget,OverOutElementsWrapper::cycleCollection OverOutElementsWrapper
::_cycleCollectorGlobal; void OverOutElementsWrapper::cycleCollection
::Unlink(void* p) { OverOutElementsWrapper* tmp = DowncastCCParticipant
<OverOutElementsWrapper>(p); ImplCycleCollectionUnlink(
tmp->mDeepestEnterEventTarget); ImplCycleCollectionUnlink(
tmp->mDispatchingOverEventTarget); ImplCycleCollectionUnlink
(tmp->mDispatchingOutOrDeepestLeaveEventTarget); (void)tmp
; } nsresult OverOutElementsWrapper::cycleCollection::TraverseNative
( void* p, nsCycleCollectionTraversalCallback& cb) { OverOutElementsWrapper
* tmp = DowncastCCParticipant<OverOutElementsWrapper>(p
); cb.DescribeRefCountedNode(tmp->mRefCnt.get(), "OverOutElementsWrapper"
); ImplCycleCollectionTraverse(cb, tmp->mDeepestEnterEventTarget
, "mDeepestEnterEventTarget", 0); ImplCycleCollectionTraverse
(cb, tmp->mDispatchingOverEventTarget, "mDispatchingOverEventTarget"
, 0); ImplCycleCollectionTraverse(cb, tmp->mDispatchingOutOrDeepestLeaveEventTarget
, "mDispatchingOutOrDeepestLeaveEventTarget", 0); (void)tmp; return
NS_OK; }
291 mDispatchingOutOrDeepestLeaveEventTarget)OverOutElementsWrapper::cycleCollection OverOutElementsWrapper
::_cycleCollectorGlobal; void OverOutElementsWrapper::cycleCollection
::Unlink(void* p) { OverOutElementsWrapper* tmp = DowncastCCParticipant
<OverOutElementsWrapper>(p); ImplCycleCollectionUnlink(
tmp->mDeepestEnterEventTarget); ImplCycleCollectionUnlink(
tmp->mDispatchingOverEventTarget); ImplCycleCollectionUnlink
(tmp->mDispatchingOutOrDeepestLeaveEventTarget); (void)tmp
; } nsresult OverOutElementsWrapper::cycleCollection::TraverseNative
( void* p, nsCycleCollectionTraversalCallback& cb) { OverOutElementsWrapper
* tmp = DowncastCCParticipant<OverOutElementsWrapper>(p
); cb.DescribeRefCountedNode(tmp->mRefCnt.get(), "OverOutElementsWrapper"
); ImplCycleCollectionTraverse(cb, tmp->mDeepestEnterEventTarget
, "mDeepestEnterEventTarget", 0); ImplCycleCollectionTraverse
(cb, tmp->mDispatchingOverEventTarget, "mDispatchingOverEventTarget"
, 0); ImplCycleCollectionTraverse(cb, tmp->mDispatchingOutOrDeepestLeaveEventTarget
, "mDispatchingOutOrDeepestLeaveEventTarget", 0); (void)tmp; return
NS_OK; }
292NS_IMPL_CYCLE_COLLECTING_ADDREF(OverOutElementsWrapper)MozExternalRefCountType OverOutElementsWrapper::AddRef(void) {
static_assert(!std::is_destructible_v<OverOutElementsWrapper
>, "Reference-counted class " "OverOutElementsWrapper" " should not have a public destructor. "
"Make this class's destructor non-public"); do { static_assert
( mozilla::detail::AssertionConditionType<decltype(int32_t
(mRefCnt) >= 0)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(int32_t(mRefCnt) >= 0))),
0))) { do { } while (false); MOZ_ReportAssertionFailure("int32_t(mRefCnt) >= 0"
" (" "illegal refcnt" ")", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 292); AnnotateMozCrashReason("MOZ_ASSERT" "(" "int32_t(mRefCnt) >= 0"
") (" "illegal refcnt" ")"); do { *((volatile int*)__null) =
292; __attribute__((nomerge)) ::abort(); } while (false); } }
while (false); _mOwningThread.AssertOwnership("OverOutElementsWrapper"
" not thread-safe"); nsISupports* base = OverOutElementsWrapper
::cycleCollection::Upcast(this); nsrefcnt count = mRefCnt.incr
(base); NS_LogAddRef((this), (count), ("OverOutElementsWrapper"
), (uint32_t)(sizeof(*this))); return count; }
293NS_IMPL_CYCLE_COLLECTING_RELEASE(OverOutElementsWrapper)MozExternalRefCountType OverOutElementsWrapper::Release(void)
{ do { static_assert( mozilla::detail::AssertionConditionType
<decltype(int32_t(mRefCnt) > 0)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(int32_t(mRefCnt) > 0))), 0
))) { do { } while (false); MOZ_ReportAssertionFailure("int32_t(mRefCnt) > 0"
" (" "dup release" ")", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 293); AnnotateMozCrashReason("MOZ_ASSERT" "(" "int32_t(mRefCnt) > 0"
") (" "dup release" ")"); do { *((volatile int*)__null) = 293
; __attribute__((nomerge)) ::abort(); } while (false); } } while
(false); _mOwningThread.AssertOwnership("OverOutElementsWrapper"
" not thread-safe"); nsISupports* base = OverOutElementsWrapper
::cycleCollection::Upcast(this); nsrefcnt count = mRefCnt.decr
(base); NS_LogRelease((this), (count), ("OverOutElementsWrapper"
)); return count; } void OverOutElementsWrapper::DeleteCycleCollectable
(void) { delete (this); }
294
295NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(OverOutElementsWrapper)nsresult OverOutElementsWrapper::QueryInterface(const nsIID&
aIID, void** aInstancePtr) { do { if (!(aInstancePtr)) { NS_DebugBreak
(NS_DEBUG_ASSERTION, "QueryInterface requires a non-NULL destination!"
, "aInstancePtr", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 295); MOZ_PretendNoReturn(); } } while (0); nsISupports* foundInterface
; if (TopThreeWordsEquals( aIID, (nsXPCOMCycleCollectionParticipant
::COMTypeInfo<nsXPCOMCycleCollectionParticipant, void>::
kIID), (nsCycleCollectionISupports::COMTypeInfo<nsCycleCollectionISupports
, void>::kIID)) && (LowWordEquals(aIID, (nsXPCOMCycleCollectionParticipant
::COMTypeInfo<nsXPCOMCycleCollectionParticipant, void>::
kIID)) || LowWordEquals(aIID, (nsCycleCollectionISupports::COMTypeInfo
<nsCycleCollectionISupports, void>::kIID)))) { if (LowWordEquals
(aIID, (nsXPCOMCycleCollectionParticipant::COMTypeInfo<nsXPCOMCycleCollectionParticipant
, void>::kIID))) { *aInstancePtr = OverOutElementsWrapper::
cycleCollection::GetParticipant(); return NS_OK; } if (LowWordEquals
(aIID, (nsCycleCollectionISupports::COMTypeInfo<nsCycleCollectionISupports
, void>::kIID))) { *aInstancePtr = OverOutElementsWrapper::
cycleCollection::Upcast(this); return NS_OK; } foundInterface
= nullptr; } else
296 NS_INTERFACE_MAP_ENTRY(nsISupports)if (aIID.Equals(mozilla::detail::kImplementedIID<std::remove_reference_t
<decltype(*this)>, nsISupports>)) foundInterface = static_cast
<nsISupports*>(this); else
297NS_INTERFACE_MAP_ENDfoundInterface = 0; nsresult status; if (!foundInterface) { do
{ static_assert( mozilla::detail::AssertionConditionType<
decltype(!aIID.Equals((nsISupports::COMTypeInfo<nsISupports
, void>::kIID)))>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!aIID.Equals((nsISupports::COMTypeInfo
<nsISupports, void>::kIID))))), 0))) { do { } while (false
); MOZ_ReportAssertionFailure("!aIID.Equals((nsISupports::COMTypeInfo<nsISupports, void>::kIID))"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 297); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!aIID.Equals((nsISupports::COMTypeInfo<nsISupports, void>::kIID))"
")"); do { *((volatile int*)__null) = 297; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); status = NS_NOINTERFACE
; } else { (foundInterface)->AddRef(); status = NS_OK; } *
aInstancePtr = foundInterface; return status; }
298
299void OverOutElementsWrapper::ContentRemoved(nsIContent& aContent) {
300 if (!mDeepestEnterEventTarget) {
301 return;
302 }
303
304 if (!nsContentUtils::ContentIsFlattenedTreeDescendantOf(
305 mDeepestEnterEventTarget, &aContent)) {
306 return;
307 }
308
309 LogModule* const logModule = mType == BoundaryEventType::Mouse
310 ? sMouseBoundaryLog
311 : sPointerBoundaryLog;
312
313 if (!StaticPrefs::
314 dom_events_mouse_pointer_boundary_keep_enter_targets_after_over_target_removed()) {
315 MOZ_LOG(logModule, LogLevel::Info,do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "The last \"over\" event target (%p) is removed"
, mDeepestEnterEventTarget.get()); } } while (0)
316 ("The last \"over\" event target (%p) is removed",do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "The last \"over\" event target (%p) is removed"
, mDeepestEnterEventTarget.get()); } } while (0)
317 mDeepestEnterEventTarget.get()))do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "The last \"over\" event target (%p) is removed"
, mDeepestEnterEventTarget.get()); } } while (0)
;
318 mDeepestEnterEventTarget = nullptr;
319 return;
320 }
321
322 if (mDispatchingOverEventTarget &&
323 (mDeepestEnterEventTarget == mDispatchingOverEventTarget ||
324 nsContentUtils::ContentIsFlattenedTreeDescendantOf(
325 mDispatchingOverEventTarget, &aContent))) {
326 if (mDispatchingOverEventTarget ==
327 mDispatchingOutOrDeepestLeaveEventTarget) {
328 MOZ_LOG(logModule, LogLevel::Info,do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "The dispatching \"%s\" event target (%p) is removed"
, mDeepestEnterEventTargetIsOverEventTarget ? "out" : "leave"
, mDispatchingOutOrDeepestLeaveEventTarget.get()); } } while (
0)
329 ("The dispatching \"%s\" event target (%p) is removed",do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "The dispatching \"%s\" event target (%p) is removed"
, mDeepestEnterEventTargetIsOverEventTarget ? "out" : "leave"
, mDispatchingOutOrDeepestLeaveEventTarget.get()); } } while (
0)
330 mDeepestEnterEventTargetIsOverEventTarget ? "out" : "leave",do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "The dispatching \"%s\" event target (%p) is removed"
, mDeepestEnterEventTargetIsOverEventTarget ? "out" : "leave"
, mDispatchingOutOrDeepestLeaveEventTarget.get()); } } while (
0)
331 mDispatchingOutOrDeepestLeaveEventTarget.get()))do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "The dispatching \"%s\" event target (%p) is removed"
, mDeepestEnterEventTargetIsOverEventTarget ? "out" : "leave"
, mDispatchingOutOrDeepestLeaveEventTarget.get()); } } while (
0)
;
332 mDispatchingOutOrDeepestLeaveEventTarget = nullptr;
333 }
334 MOZ_LOG(logModule, LogLevel::Info,do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "The dispatching \"over\" event target (%p) is removed"
, mDispatchingOverEventTarget.get()); } } while (0)
335 ("The dispatching \"over\" event target (%p) is removed",do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "The dispatching \"over\" event target (%p) is removed"
, mDispatchingOverEventTarget.get()); } } while (0)
336 mDispatchingOverEventTarget.get()))do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "The dispatching \"over\" event target (%p) is removed"
, mDispatchingOverEventTarget.get()); } } while (0)
;
337 mDispatchingOverEventTarget = nullptr;
338 }
339 if (mDispatchingOutOrDeepestLeaveEventTarget &&
340 (mDeepestEnterEventTarget == mDispatchingOutOrDeepestLeaveEventTarget ||
341 nsContentUtils::ContentIsFlattenedTreeDescendantOf(
342 mDispatchingOutOrDeepestLeaveEventTarget, &aContent))) {
343 MOZ_LOG(logModule, LogLevel::Info,do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "The dispatching \"%s\" event target (%p) is removed"
, mDeepestEnterEventTargetIsOverEventTarget ? "out" : "leave"
, mDispatchingOutOrDeepestLeaveEventTarget.get()); } } while (
0)
344 ("The dispatching \"%s\" event target (%p) is removed",do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "The dispatching \"%s\" event target (%p) is removed"
, mDeepestEnterEventTargetIsOverEventTarget ? "out" : "leave"
, mDispatchingOutOrDeepestLeaveEventTarget.get()); } } while (
0)
345 mDeepestEnterEventTargetIsOverEventTarget ? "out" : "leave",do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "The dispatching \"%s\" event target (%p) is removed"
, mDeepestEnterEventTargetIsOverEventTarget ? "out" : "leave"
, mDispatchingOutOrDeepestLeaveEventTarget.get()); } } while (
0)
346 mDispatchingOutOrDeepestLeaveEventTarget.get()))do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "The dispatching \"%s\" event target (%p) is removed"
, mDeepestEnterEventTargetIsOverEventTarget ? "out" : "leave"
, mDispatchingOutOrDeepestLeaveEventTarget.get()); } } while (
0)
;
347 mDispatchingOutOrDeepestLeaveEventTarget = nullptr;
348 }
349 MOZ_LOG(logModule, LogLevel::Info,do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "The last \"%s\" event target (%p) is removed and now the last "
"deepest enter target becomes %s(%p)", mDeepestEnterEventTargetIsOverEventTarget
? "over" : "enter", mDeepestEnterEventTarget.get(), aContent
.GetFlattenedTreeParent() ? ToString(*aContent.GetFlattenedTreeParent
()).c_str() : "nullptr", aContent.GetFlattenedTreeParent()); }
} while (0)
350 ("The last \"%s\" event target (%p) is removed and now the last "do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "The last \"%s\" event target (%p) is removed and now the last "
"deepest enter target becomes %s(%p)", mDeepestEnterEventTargetIsOverEventTarget
? "over" : "enter", mDeepestEnterEventTarget.get(), aContent
.GetFlattenedTreeParent() ? ToString(*aContent.GetFlattenedTreeParent
()).c_str() : "nullptr", aContent.GetFlattenedTreeParent()); }
} while (0)
351 "deepest enter target becomes %s(%p)",do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "The last \"%s\" event target (%p) is removed and now the last "
"deepest enter target becomes %s(%p)", mDeepestEnterEventTargetIsOverEventTarget
? "over" : "enter", mDeepestEnterEventTarget.get(), aContent
.GetFlattenedTreeParent() ? ToString(*aContent.GetFlattenedTreeParent
()).c_str() : "nullptr", aContent.GetFlattenedTreeParent()); }
} while (0)
352 mDeepestEnterEventTargetIsOverEventTarget ? "over" : "enter",do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "The last \"%s\" event target (%p) is removed and now the last "
"deepest enter target becomes %s(%p)", mDeepestEnterEventTargetIsOverEventTarget
? "over" : "enter", mDeepestEnterEventTarget.get(), aContent
.GetFlattenedTreeParent() ? ToString(*aContent.GetFlattenedTreeParent
()).c_str() : "nullptr", aContent.GetFlattenedTreeParent()); }
} while (0)
353 mDeepestEnterEventTarget.get(),do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "The last \"%s\" event target (%p) is removed and now the last "
"deepest enter target becomes %s(%p)", mDeepestEnterEventTargetIsOverEventTarget
? "over" : "enter", mDeepestEnterEventTarget.get(), aContent
.GetFlattenedTreeParent() ? ToString(*aContent.GetFlattenedTreeParent
()).c_str() : "nullptr", aContent.GetFlattenedTreeParent()); }
} while (0)
354 aContent.GetFlattenedTreeParent()do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "The last \"%s\" event target (%p) is removed and now the last "
"deepest enter target becomes %s(%p)", mDeepestEnterEventTargetIsOverEventTarget
? "over" : "enter", mDeepestEnterEventTarget.get(), aContent
.GetFlattenedTreeParent() ? ToString(*aContent.GetFlattenedTreeParent
()).c_str() : "nullptr", aContent.GetFlattenedTreeParent()); }
} while (0)
355 ? ToString(*aContent.GetFlattenedTreeParent()).c_str()do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "The last \"%s\" event target (%p) is removed and now the last "
"deepest enter target becomes %s(%p)", mDeepestEnterEventTargetIsOverEventTarget
? "over" : "enter", mDeepestEnterEventTarget.get(), aContent
.GetFlattenedTreeParent() ? ToString(*aContent.GetFlattenedTreeParent
()).c_str() : "nullptr", aContent.GetFlattenedTreeParent()); }
} while (0)
356 : "nullptr",do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "The last \"%s\" event target (%p) is removed and now the last "
"deepest enter target becomes %s(%p)", mDeepestEnterEventTargetIsOverEventTarget
? "over" : "enter", mDeepestEnterEventTarget.get(), aContent
.GetFlattenedTreeParent() ? ToString(*aContent.GetFlattenedTreeParent
()).c_str() : "nullptr", aContent.GetFlattenedTreeParent()); }
} while (0)
357 aContent.GetFlattenedTreeParent()))do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "The last \"%s\" event target (%p) is removed and now the last "
"deepest enter target becomes %s(%p)", mDeepestEnterEventTargetIsOverEventTarget
? "over" : "enter", mDeepestEnterEventTarget.get(), aContent
.GetFlattenedTreeParent() ? ToString(*aContent.GetFlattenedTreeParent
()).c_str() : "nullptr", aContent.GetFlattenedTreeParent()); }
} while (0)
;
358 mDeepestEnterEventTarget = aContent.GetFlattenedTreeParent();
359 mDeepestEnterEventTargetIsOverEventTarget = false;
360}
361
362void OverOutElementsWrapper::DidDispatchOverAndEnterEvent(
363 nsIContent* aOriginalOverTargetInComposedDoc) {
364 mDispatchingOverEventTarget = nullptr;
365
366 // Pointer Events define that once the `pointerover` event target is removed
367 // from the tree, `pointerout` should not be fired on that and the closest
368 // connected ancestor at the target removal should be kept as the deepest
369 // `pointerleave` target. Therefore, we don't need the special handling for
370 // `pointerout` event target if the last `pointerover` target is temporarily
371 // removed from the tree.
372 if (mType == OverOutElementsWrapper::BoundaryEventType::Pointer) {
373 return;
374 }
375
376 // Assume that the caller checks whether aOriginalOverTarget is in the
377 // original document. If we don't enable the strict mouse/pointer event
378 // boundary event dispatching by the pref (see below),
379 // mDeepestEnterEventTarget is set to nullptr when the last "over" target is
380 // removed. Therefore, we cannot check whether aOriginalOverTarget is in the
381 // original document here.
382 if (!aOriginalOverTargetInComposedDoc) {
383 return;
384 }
385 MOZ_ASSERT_IF(mDeepestEnterEventTarget,do { if (mDeepestEnterEventTarget) { do { static_assert( mozilla
::detail::AssertionConditionType<decltype(mDeepestEnterEventTarget
->GetComposedDoc() == aOriginalOverTargetInComposedDoc->
GetComposedDoc())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mDeepestEnterEventTarget->
GetComposedDoc() == aOriginalOverTargetInComposedDoc->GetComposedDoc
()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("mDeepestEnterEventTarget->GetComposedDoc() == aOriginalOverTargetInComposedDoc->GetComposedDoc()"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 387); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mDeepestEnterEventTarget->GetComposedDoc() == aOriginalOverTargetInComposedDoc->GetComposedDoc()"
")"); do { *((volatile int*)__null) = 387; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
386 mDeepestEnterEventTarget->GetComposedDoc() ==do { if (mDeepestEnterEventTarget) { do { static_assert( mozilla
::detail::AssertionConditionType<decltype(mDeepestEnterEventTarget
->GetComposedDoc() == aOriginalOverTargetInComposedDoc->
GetComposedDoc())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mDeepestEnterEventTarget->
GetComposedDoc() == aOriginalOverTargetInComposedDoc->GetComposedDoc
()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("mDeepestEnterEventTarget->GetComposedDoc() == aOriginalOverTargetInComposedDoc->GetComposedDoc()"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 387); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mDeepestEnterEventTarget->GetComposedDoc() == aOriginalOverTargetInComposedDoc->GetComposedDoc()"
")"); do { *((volatile int*)__null) = 387; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
387 aOriginalOverTargetInComposedDoc->GetComposedDoc())do { if (mDeepestEnterEventTarget) { do { static_assert( mozilla
::detail::AssertionConditionType<decltype(mDeepestEnterEventTarget
->GetComposedDoc() == aOriginalOverTargetInComposedDoc->
GetComposedDoc())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mDeepestEnterEventTarget->
GetComposedDoc() == aOriginalOverTargetInComposedDoc->GetComposedDoc
()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("mDeepestEnterEventTarget->GetComposedDoc() == aOriginalOverTargetInComposedDoc->GetComposedDoc()"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 387); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mDeepestEnterEventTarget->GetComposedDoc() == aOriginalOverTargetInComposedDoc->GetComposedDoc()"
")"); do { *((volatile int*)__null) = 387; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
;
388 // If the "mouseover" event target is removed temporarily while we're
389 // dispatching "mouseover" and "mouseenter" events and the target gets back
390 // under the deepest enter event target, we should restore the "mouseover"
391 // target.
392 if ((!StaticPrefs::
393 dom_events_mouse_pointer_boundary_keep_enter_targets_after_over_target_removed() &&
394 !mDeepestEnterEventTarget) ||
395 (!mDeepestEnterEventTargetIsOverEventTarget && mDeepestEnterEventTarget &&
396 nsContentUtils::ContentIsFlattenedTreeDescendantOf(
397 aOriginalOverTargetInComposedDoc, mDeepestEnterEventTarget))) {
398 mDeepestEnterEventTarget = aOriginalOverTargetInComposedDoc;
399 mDeepestEnterEventTargetIsOverEventTarget = true;
400 LogModule* const logModule = mType == BoundaryEventType::Mouse
401 ? sMouseBoundaryLog
402 : sPointerBoundaryLog;
403 MOZ_LOG(logModule, LogLevel::Info,do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "The \"over\" event target (%p) is restored"
, mDeepestEnterEventTarget.get()); } } while (0)
404 ("The \"over\" event target (%p) is restored",do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "The \"over\" event target (%p) is restored"
, mDeepestEnterEventTarget.get()); } } while (0)
405 mDeepestEnterEventTarget.get()))do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "The \"over\" event target (%p) is restored"
, mDeepestEnterEventTarget.get()); } } while (0)
;
406 }
407}
408
409/******************************************************************/
410/* mozilla::EventStateManager */
411/******************************************************************/
412
413static uint32_t sESMInstanceCount = 0;
414
415bool EventStateManager::sNormalLMouseEventInProcess = false;
416int16_t EventStateManager::sCurrentMouseBtn = MouseButton::eNotPressed;
417EventStateManager* EventStateManager::sActiveESM = nullptr;
418EventStateManager* EventStateManager::sCursorSettingManager = nullptr;
419AutoWeakFrame EventStateManager::sLastDragOverFrame = nullptr;
420LayoutDeviceIntPoint EventStateManager::sPreLockScreenPoint =
421 LayoutDeviceIntPoint(0, 0);
422LayoutDeviceIntPoint EventStateManager::sLastRefPoint = kInvalidRefPoint;
423CSSIntPoint EventStateManager::sLastScreenPoint = CSSIntPoint(0, 0);
424LayoutDeviceIntPoint EventStateManager::sSynthCenteringPoint = kInvalidRefPoint;
425CSSIntPoint EventStateManager::sLastClientPoint = CSSIntPoint(0, 0);
426nsCOMPtr<nsIContent> EventStateManager::sDragOverContent = nullptr;
427
428EventStateManager::WheelPrefs* EventStateManager::WheelPrefs::sInstance =
429 nullptr;
430EventStateManager::DeltaAccumulator*
431 EventStateManager::DeltaAccumulator::sInstance = nullptr;
432
433constexpr const StyleCursorKind kInvalidCursorKind =
434 static_cast<StyleCursorKind>(255);
435
436EventStateManager::EventStateManager()
437 : mLockCursor(kInvalidCursorKind),
438 mCurrentTarget(nullptr),
439 // init d&d gesture state machine variables
440 mGestureDownPoint(0, 0),
441 mGestureModifiers(0),
442 mGestureDownButtons(0),
443 mPresContext(nullptr),
444 mShouldAlwaysUseLineDeltas(false),
445 mShouldAlwaysUseLineDeltasInitialized(false),
446 mGestureDownInTextControl(false),
447 mInTouchDrag(false),
448 m_haveShutdown(false) {
449 if (sESMInstanceCount == 0) {
450 gUserInteractionTimerCallback = new UITimerCallback();
451 if (gUserInteractionTimerCallback) NS_ADDREF(gUserInteractionTimerCallback)(gUserInteractionTimerCallback)->AddRef();
452 UpdateUserActivityTimer();
453 }
454 ++sESMInstanceCount;
455}
456
457nsresult EventStateManager::UpdateUserActivityTimer() {
458 if (!gUserInteractionTimerCallback) return NS_OK;
459
460 if (!gUserInteractionTimer) {
461 gUserInteractionTimer = NS_NewTimer().take();
462 }
463
464 if (gUserInteractionTimer) {
465 gUserInteractionTimer->InitWithCallback(
466 gUserInteractionTimerCallback,
467 StaticPrefs::dom_events_user_interaction_interval(),
468 nsITimer::TYPE_ONE_SHOT);
469 }
470 return NS_OK;
471}
472
473nsresult EventStateManager::Init() {
474 nsCOMPtr<nsIObserverService> observerService =
475 mozilla::services::GetObserverService();
476 if (!observerService) return NS_ERROR_FAILURE;
477
478 observerService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID"xpcom-shutdown", true);
479
480 return NS_OK;
481}
482
483bool EventStateManager::ShouldAlwaysUseLineDeltas() {
484 if (MOZ_UNLIKELY(!mShouldAlwaysUseLineDeltasInitialized)(__builtin_expect(!!(!mShouldAlwaysUseLineDeltasInitialized),
0))
) {
485 mShouldAlwaysUseLineDeltasInitialized = true;
486 mShouldAlwaysUseLineDeltas =
487 !StaticPrefs::dom_event_wheel_deltaMode_lines_disabled();
488 if (!mShouldAlwaysUseLineDeltas && mDocument) {
489 if (nsIPrincipal* principal =
490 mDocument->GetPrincipalForPrefBasedHacks()) {
491 mShouldAlwaysUseLineDeltas = principal->IsURIInPrefList(
492 "dom.event.wheel-deltaMode-lines.always-enabled");
493 }
494 }
495 }
496 return mShouldAlwaysUseLineDeltas;
497}
498
499EventStateManager::~EventStateManager() {
500 ReleaseCurrentIMEContentObserver();
501
502 if (sActiveESM == this) {
503 sActiveESM = nullptr;
504 }
505
506 if (StaticPrefs::ui_click_hold_context_menus()) {
507 KillClickHoldTimer();
508 }
509
510 if (sCursorSettingManager == this) {
511 sCursorSettingManager = nullptr;
512 }
513
514 --sESMInstanceCount;
515 if (sESMInstanceCount == 0) {
516 WheelTransaction::Shutdown();
517 if (gUserInteractionTimerCallback) {
518 gUserInteractionTimerCallback->Notify(nullptr);
519 NS_RELEASE(gUserInteractionTimerCallback)do { (gUserInteractionTimerCallback)->Release(); (gUserInteractionTimerCallback
) = 0; } while (0)
;
520 }
521 if (gUserInteractionTimer) {
522 gUserInteractionTimer->Cancel();
523 NS_RELEASE(gUserInteractionTimer)do { (gUserInteractionTimer)->Release(); (gUserInteractionTimer
) = 0; } while (0)
;
524 }
525 WheelPrefs::Shutdown();
526 DeltaAccumulator::Shutdown();
527 }
528
529 if (sDragOverContent && sDragOverContent->OwnerDoc() == mDocument) {
530 sDragOverContent = nullptr;
531 }
532
533 if (!m_haveShutdown) {
534 Shutdown();
535
536 // Don't remove from Observer service in Shutdown because Shutdown also
537 // gets called from xpcom shutdown observer. And we don't want to remove
538 // from the service in that case.
539
540 nsCOMPtr<nsIObserverService> observerService =
541 mozilla::services::GetObserverService();
542 if (observerService) {
543 observerService->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID"xpcom-shutdown");
544 }
545 }
546}
547
548nsresult EventStateManager::Shutdown() {
549 m_haveShutdown = true;
550 return NS_OK;
551}
552
553NS_IMETHODIMPnsresult
554EventStateManager::Observe(nsISupports* aSubject, const char* aTopic,
555 const char16_t* someData) {
556 if (!nsCRT::strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID"xpcom-shutdown")) {
557 Shutdown();
558 }
559
560 return NS_OK;
561}
562
563NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(EventStateManager)nsresult EventStateManager::QueryInterface(const nsIID& aIID
, void** aInstancePtr) { do { if (!(aInstancePtr)) { NS_DebugBreak
(NS_DEBUG_ASSERTION, "QueryInterface requires a non-NULL destination!"
, "aInstancePtr", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 563); MOZ_PretendNoReturn(); } } while (0); nsISupports* foundInterface
; if (TopThreeWordsEquals( aIID, (nsXPCOMCycleCollectionParticipant
::COMTypeInfo<nsXPCOMCycleCollectionParticipant, void>::
kIID), (nsCycleCollectionISupports::COMTypeInfo<nsCycleCollectionISupports
, void>::kIID)) && (LowWordEquals(aIID, (nsXPCOMCycleCollectionParticipant
::COMTypeInfo<nsXPCOMCycleCollectionParticipant, void>::
kIID)) || LowWordEquals(aIID, (nsCycleCollectionISupports::COMTypeInfo
<nsCycleCollectionISupports, void>::kIID)))) { if (LowWordEquals
(aIID, (nsXPCOMCycleCollectionParticipant::COMTypeInfo<nsXPCOMCycleCollectionParticipant
, void>::kIID))) { *aInstancePtr = EventStateManager::cycleCollection
::GetParticipant(); return NS_OK; } if (LowWordEquals(aIID, (
nsCycleCollectionISupports::COMTypeInfo<nsCycleCollectionISupports
, void>::kIID))) { *aInstancePtr = EventStateManager::cycleCollection
::Upcast(this); return NS_OK; } foundInterface = nullptr; } else
564 NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIObserver)if (aIID.Equals(mozilla::detail::kImplementedIID<std::remove_reference_t
<decltype(*this)>, nsISupports>)) foundInterface = static_cast
<nsISupports*>(static_cast<nsIObserver*>(this)); else
565 NS_INTERFACE_MAP_ENTRY(nsIObserver)if (aIID.Equals(mozilla::detail::kImplementedIID<std::remove_reference_t
<decltype(*this)>, nsIObserver>)) foundInterface = static_cast
<nsIObserver*>(this); else
566 NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)if (aIID.Equals(mozilla::detail::kImplementedIID<std::remove_reference_t
<decltype(*this)>, nsISupportsWeakReference>)) foundInterface
= static_cast<nsISupportsWeakReference*>(this); else
567NS_INTERFACE_MAP_ENDfoundInterface = 0; nsresult status; if (!foundInterface) { do
{ static_assert( mozilla::detail::AssertionConditionType<
decltype(!aIID.Equals((nsISupports::COMTypeInfo<nsISupports
, void>::kIID)))>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!aIID.Equals((nsISupports::COMTypeInfo
<nsISupports, void>::kIID))))), 0))) { do { } while (false
); MOZ_ReportAssertionFailure("!aIID.Equals((nsISupports::COMTypeInfo<nsISupports, void>::kIID))"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 567); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!aIID.Equals((nsISupports::COMTypeInfo<nsISupports, void>::kIID))"
")"); do { *((volatile int*)__null) = 567; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); status = NS_NOINTERFACE
; } else { (foundInterface)->AddRef(); status = NS_OK; } *
aInstancePtr = foundInterface; return status; }
568
569NS_IMPL_CYCLE_COLLECTING_ADDREF(EventStateManager)MozExternalRefCountType EventStateManager::AddRef(void) { static_assert
(!std::is_destructible_v<EventStateManager>, "Reference-counted class "
"EventStateManager" " should not have a public destructor. "
"Make this class's destructor non-public"); do { static_assert
( mozilla::detail::AssertionConditionType<decltype(int32_t
(mRefCnt) >= 0)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(int32_t(mRefCnt) >= 0))),
0))) { do { } while (false); MOZ_ReportAssertionFailure("int32_t(mRefCnt) >= 0"
" (" "illegal refcnt" ")", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 569); AnnotateMozCrashReason("MOZ_ASSERT" "(" "int32_t(mRefCnt) >= 0"
") (" "illegal refcnt" ")"); do { *((volatile int*)__null) =
569; __attribute__((nomerge)) ::abort(); } while (false); } }
while (false); _mOwningThread.AssertOwnership("EventStateManager"
" not thread-safe"); nsISupports* base = EventStateManager::
cycleCollection::Upcast(this); nsrefcnt count = mRefCnt.incr(
base); NS_LogAddRef((this), (count), ("EventStateManager"), (
uint32_t)(sizeof(*this))); return count; }
570NS_IMPL_CYCLE_COLLECTING_RELEASE(EventStateManager)MozExternalRefCountType EventStateManager::Release(void) { do
{ static_assert( mozilla::detail::AssertionConditionType<
decltype(int32_t(mRefCnt) > 0)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(int32_t(mRefCnt) > 0))), 0
))) { do { } while (false); MOZ_ReportAssertionFailure("int32_t(mRefCnt) > 0"
" (" "dup release" ")", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 570); AnnotateMozCrashReason("MOZ_ASSERT" "(" "int32_t(mRefCnt) > 0"
") (" "dup release" ")"); do { *((volatile int*)__null) = 570
; __attribute__((nomerge)) ::abort(); } while (false); } } while
(false); _mOwningThread.AssertOwnership("EventStateManager" " not thread-safe"
); nsISupports* base = EventStateManager::cycleCollection::Upcast
(this); nsrefcnt count = mRefCnt.decr(base); NS_LogRelease((this
), (count), ("EventStateManager")); return count; } void EventStateManager
::DeleteCycleCollectable(void) { delete (this); }
571
572NS_IMPL_CYCLE_COLLECTION_WEAK(EventStateManager, mCurrentTargetContent,EventStateManager::cycleCollection EventStateManager::_cycleCollectorGlobal
; void EventStateManager::cycleCollection::Unlink(void* p) { EventStateManager
* tmp = DowncastCCParticipant<EventStateManager>(p); ImplCycleCollectionUnlink
(tmp->mCurrentTargetContent); ImplCycleCollectionUnlink(tmp
->mGestureDownContent); ImplCycleCollectionUnlink(tmp->
mGestureDownFrameOwner); ImplCycleCollectionUnlink(tmp->mLastLeftMouseDownInfo
.mLastMouseDownContent); ImplCycleCollectionUnlink(tmp->mLastMiddleMouseDownInfo
.mLastMouseDownContent); ImplCycleCollectionUnlink(tmp->mLastRightMouseDownInfo
.mLastMouseDownContent); ImplCycleCollectionUnlink(tmp->mActiveContent
); ImplCycleCollectionUnlink(tmp->mHoverContent); ImplCycleCollectionUnlink
(tmp->mURLTargetContent); ImplCycleCollectionUnlink(tmp->
mPopoverPointerDownTarget); ImplCycleCollectionUnlink(tmp->
mMouseEnterLeaveHelper); ImplCycleCollectionUnlink(tmp->mPointersEnterLeaveHelper
); ImplCycleCollectionUnlink(tmp->mDocument); ImplCycleCollectionUnlink
(tmp->mIMEContentObserver); ImplCycleCollectionUnlink(tmp->
mAccessKeys); tmp->ClearWeakReferences(); (void)tmp; } nsresult
EventStateManager::cycleCollection::TraverseNative( void* p,
nsCycleCollectionTraversalCallback& cb) { EventStateManager
* tmp = DowncastCCParticipant<EventStateManager>(p); cb
.DescribeRefCountedNode(tmp->mRefCnt.get(), "EventStateManager"
); ImplCycleCollectionTraverse(cb, tmp->mCurrentTargetContent
, "mCurrentTargetContent", 0); ImplCycleCollectionTraverse(cb
, tmp->mGestureDownContent, "mGestureDownContent", 0); ImplCycleCollectionTraverse
(cb, tmp->mGestureDownFrameOwner, "mGestureDownFrameOwner"
, 0); ImplCycleCollectionTraverse(cb, tmp->mLastLeftMouseDownInfo
.mLastMouseDownContent, "mLastLeftMouseDownInfo.mLastMouseDownContent"
, 0); ImplCycleCollectionTraverse(cb, tmp->mLastMiddleMouseDownInfo
.mLastMouseDownContent, "mLastMiddleMouseDownInfo.mLastMouseDownContent"
, 0); ImplCycleCollectionTraverse(cb, tmp->mLastRightMouseDownInfo
.mLastMouseDownContent, "mLastRightMouseDownInfo.mLastMouseDownContent"
, 0); ImplCycleCollectionTraverse(cb, tmp->mActiveContent,
"mActiveContent", 0); ImplCycleCollectionTraverse(cb, tmp->
mHoverContent, "mHoverContent", 0); ImplCycleCollectionTraverse
(cb, tmp->mURLTargetContent, "mURLTargetContent", 0); ImplCycleCollectionTraverse
(cb, tmp->mPopoverPointerDownTarget, "mPopoverPointerDownTarget"
, 0); ImplCycleCollectionTraverse(cb, tmp->mMouseEnterLeaveHelper
, "mMouseEnterLeaveHelper", 0); ImplCycleCollectionTraverse(cb
, tmp->mPointersEnterLeaveHelper, "mPointersEnterLeaveHelper"
, 0); ImplCycleCollectionTraverse(cb, tmp->mDocument, "mDocument"
, 0); ImplCycleCollectionTraverse(cb, tmp->mIMEContentObserver
, "mIMEContentObserver", 0); ImplCycleCollectionTraverse(cb, tmp
->mAccessKeys, "mAccessKeys", 0); (void)tmp; return NS_OK;
}
573 mGestureDownContent, mGestureDownFrameOwner,EventStateManager::cycleCollection EventStateManager::_cycleCollectorGlobal
; void EventStateManager::cycleCollection::Unlink(void* p) { EventStateManager
* tmp = DowncastCCParticipant<EventStateManager>(p); ImplCycleCollectionUnlink
(tmp->mCurrentTargetContent); ImplCycleCollectionUnlink(tmp
->mGestureDownContent); ImplCycleCollectionUnlink(tmp->
mGestureDownFrameOwner); ImplCycleCollectionUnlink(tmp->mLastLeftMouseDownInfo
.mLastMouseDownContent); ImplCycleCollectionUnlink(tmp->mLastMiddleMouseDownInfo
.mLastMouseDownContent); ImplCycleCollectionUnlink(tmp->mLastRightMouseDownInfo
.mLastMouseDownContent); ImplCycleCollectionUnlink(tmp->mActiveContent
); ImplCycleCollectionUnlink(tmp->mHoverContent); ImplCycleCollectionUnlink
(tmp->mURLTargetContent); ImplCycleCollectionUnlink(tmp->
mPopoverPointerDownTarget); ImplCycleCollectionUnlink(tmp->
mMouseEnterLeaveHelper); ImplCycleCollectionUnlink(tmp->mPointersEnterLeaveHelper
); ImplCycleCollectionUnlink(tmp->mDocument); ImplCycleCollectionUnlink
(tmp->mIMEContentObserver); ImplCycleCollectionUnlink(tmp->
mAccessKeys); tmp->ClearWeakReferences(); (void)tmp; } nsresult
EventStateManager::cycleCollection::TraverseNative( void* p,
nsCycleCollectionTraversalCallback& cb) { EventStateManager
* tmp = DowncastCCParticipant<EventStateManager>(p); cb
.DescribeRefCountedNode(tmp->mRefCnt.get(), "EventStateManager"
); ImplCycleCollectionTraverse(cb, tmp->mCurrentTargetContent
, "mCurrentTargetContent", 0); ImplCycleCollectionTraverse(cb
, tmp->mGestureDownContent, "mGestureDownContent", 0); ImplCycleCollectionTraverse
(cb, tmp->mGestureDownFrameOwner, "mGestureDownFrameOwner"
, 0); ImplCycleCollectionTraverse(cb, tmp->mLastLeftMouseDownInfo
.mLastMouseDownContent, "mLastLeftMouseDownInfo.mLastMouseDownContent"
, 0); ImplCycleCollectionTraverse(cb, tmp->mLastMiddleMouseDownInfo
.mLastMouseDownContent, "mLastMiddleMouseDownInfo.mLastMouseDownContent"
, 0); ImplCycleCollectionTraverse(cb, tmp->mLastRightMouseDownInfo
.mLastMouseDownContent, "mLastRightMouseDownInfo.mLastMouseDownContent"
, 0); ImplCycleCollectionTraverse(cb, tmp->mActiveContent,
"mActiveContent", 0); ImplCycleCollectionTraverse(cb, tmp->
mHoverContent, "mHoverContent", 0); ImplCycleCollectionTraverse
(cb, tmp->mURLTargetContent, "mURLTargetContent", 0); ImplCycleCollectionTraverse
(cb, tmp->mPopoverPointerDownTarget, "mPopoverPointerDownTarget"
, 0); ImplCycleCollectionTraverse(cb, tmp->mMouseEnterLeaveHelper
, "mMouseEnterLeaveHelper", 0); ImplCycleCollectionTraverse(cb
, tmp->mPointersEnterLeaveHelper, "mPointersEnterLeaveHelper"
, 0); ImplCycleCollectionTraverse(cb, tmp->mDocument, "mDocument"
, 0); ImplCycleCollectionTraverse(cb, tmp->mIMEContentObserver
, "mIMEContentObserver", 0); ImplCycleCollectionTraverse(cb, tmp
->mAccessKeys, "mAccessKeys", 0); (void)tmp; return NS_OK;
}
574 mLastLeftMouseDownInfo.mLastMouseDownContent,EventStateManager::cycleCollection EventStateManager::_cycleCollectorGlobal
; void EventStateManager::cycleCollection::Unlink(void* p) { EventStateManager
* tmp = DowncastCCParticipant<EventStateManager>(p); ImplCycleCollectionUnlink
(tmp->mCurrentTargetContent); ImplCycleCollectionUnlink(tmp
->mGestureDownContent); ImplCycleCollectionUnlink(tmp->
mGestureDownFrameOwner); ImplCycleCollectionUnlink(tmp->mLastLeftMouseDownInfo
.mLastMouseDownContent); ImplCycleCollectionUnlink(tmp->mLastMiddleMouseDownInfo
.mLastMouseDownContent); ImplCycleCollectionUnlink(tmp->mLastRightMouseDownInfo
.mLastMouseDownContent); ImplCycleCollectionUnlink(tmp->mActiveContent
); ImplCycleCollectionUnlink(tmp->mHoverContent); ImplCycleCollectionUnlink
(tmp->mURLTargetContent); ImplCycleCollectionUnlink(tmp->
mPopoverPointerDownTarget); ImplCycleCollectionUnlink(tmp->
mMouseEnterLeaveHelper); ImplCycleCollectionUnlink(tmp->mPointersEnterLeaveHelper
); ImplCycleCollectionUnlink(tmp->mDocument); ImplCycleCollectionUnlink
(tmp->mIMEContentObserver); ImplCycleCollectionUnlink(tmp->
mAccessKeys); tmp->ClearWeakReferences(); (void)tmp; } nsresult
EventStateManager::cycleCollection::TraverseNative( void* p,
nsCycleCollectionTraversalCallback& cb) { EventStateManager
* tmp = DowncastCCParticipant<EventStateManager>(p); cb
.DescribeRefCountedNode(tmp->mRefCnt.get(), "EventStateManager"
); ImplCycleCollectionTraverse(cb, tmp->mCurrentTargetContent
, "mCurrentTargetContent", 0); ImplCycleCollectionTraverse(cb
, tmp->mGestureDownContent, "mGestureDownContent", 0); ImplCycleCollectionTraverse
(cb, tmp->mGestureDownFrameOwner, "mGestureDownFrameOwner"
, 0); ImplCycleCollectionTraverse(cb, tmp->mLastLeftMouseDownInfo
.mLastMouseDownContent, "mLastLeftMouseDownInfo.mLastMouseDownContent"
, 0); ImplCycleCollectionTraverse(cb, tmp->mLastMiddleMouseDownInfo
.mLastMouseDownContent, "mLastMiddleMouseDownInfo.mLastMouseDownContent"
, 0); ImplCycleCollectionTraverse(cb, tmp->mLastRightMouseDownInfo
.mLastMouseDownContent, "mLastRightMouseDownInfo.mLastMouseDownContent"
, 0); ImplCycleCollectionTraverse(cb, tmp->mActiveContent,
"mActiveContent", 0); ImplCycleCollectionTraverse(cb, tmp->
mHoverContent, "mHoverContent", 0); ImplCycleCollectionTraverse
(cb, tmp->mURLTargetContent, "mURLTargetContent", 0); ImplCycleCollectionTraverse
(cb, tmp->mPopoverPointerDownTarget, "mPopoverPointerDownTarget"
, 0); ImplCycleCollectionTraverse(cb, tmp->mMouseEnterLeaveHelper
, "mMouseEnterLeaveHelper", 0); ImplCycleCollectionTraverse(cb
, tmp->mPointersEnterLeaveHelper, "mPointersEnterLeaveHelper"
, 0); ImplCycleCollectionTraverse(cb, tmp->mDocument, "mDocument"
, 0); ImplCycleCollectionTraverse(cb, tmp->mIMEContentObserver
, "mIMEContentObserver", 0); ImplCycleCollectionTraverse(cb, tmp
->mAccessKeys, "mAccessKeys", 0); (void)tmp; return NS_OK;
}
575 mLastMiddleMouseDownInfo.mLastMouseDownContent,EventStateManager::cycleCollection EventStateManager::_cycleCollectorGlobal
; void EventStateManager::cycleCollection::Unlink(void* p) { EventStateManager
* tmp = DowncastCCParticipant<EventStateManager>(p); ImplCycleCollectionUnlink
(tmp->mCurrentTargetContent); ImplCycleCollectionUnlink(tmp
->mGestureDownContent); ImplCycleCollectionUnlink(tmp->
mGestureDownFrameOwner); ImplCycleCollectionUnlink(tmp->mLastLeftMouseDownInfo
.mLastMouseDownContent); ImplCycleCollectionUnlink(tmp->mLastMiddleMouseDownInfo
.mLastMouseDownContent); ImplCycleCollectionUnlink(tmp->mLastRightMouseDownInfo
.mLastMouseDownContent); ImplCycleCollectionUnlink(tmp->mActiveContent
); ImplCycleCollectionUnlink(tmp->mHoverContent); ImplCycleCollectionUnlink
(tmp->mURLTargetContent); ImplCycleCollectionUnlink(tmp->
mPopoverPointerDownTarget); ImplCycleCollectionUnlink(tmp->
mMouseEnterLeaveHelper); ImplCycleCollectionUnlink(tmp->mPointersEnterLeaveHelper
); ImplCycleCollectionUnlink(tmp->mDocument); ImplCycleCollectionUnlink
(tmp->mIMEContentObserver); ImplCycleCollectionUnlink(tmp->
mAccessKeys); tmp->ClearWeakReferences(); (void)tmp; } nsresult
EventStateManager::cycleCollection::TraverseNative( void* p,
nsCycleCollectionTraversalCallback& cb) { EventStateManager
* tmp = DowncastCCParticipant<EventStateManager>(p); cb
.DescribeRefCountedNode(tmp->mRefCnt.get(), "EventStateManager"
); ImplCycleCollectionTraverse(cb, tmp->mCurrentTargetContent
, "mCurrentTargetContent", 0); ImplCycleCollectionTraverse(cb
, tmp->mGestureDownContent, "mGestureDownContent", 0); ImplCycleCollectionTraverse
(cb, tmp->mGestureDownFrameOwner, "mGestureDownFrameOwner"
, 0); ImplCycleCollectionTraverse(cb, tmp->mLastLeftMouseDownInfo
.mLastMouseDownContent, "mLastLeftMouseDownInfo.mLastMouseDownContent"
, 0); ImplCycleCollectionTraverse(cb, tmp->mLastMiddleMouseDownInfo
.mLastMouseDownContent, "mLastMiddleMouseDownInfo.mLastMouseDownContent"
, 0); ImplCycleCollectionTraverse(cb, tmp->mLastRightMouseDownInfo
.mLastMouseDownContent, "mLastRightMouseDownInfo.mLastMouseDownContent"
, 0); ImplCycleCollectionTraverse(cb, tmp->mActiveContent,
"mActiveContent", 0); ImplCycleCollectionTraverse(cb, tmp->
mHoverContent, "mHoverContent", 0); ImplCycleCollectionTraverse
(cb, tmp->mURLTargetContent, "mURLTargetContent", 0); ImplCycleCollectionTraverse
(cb, tmp->mPopoverPointerDownTarget, "mPopoverPointerDownTarget"
, 0); ImplCycleCollectionTraverse(cb, tmp->mMouseEnterLeaveHelper
, "mMouseEnterLeaveHelper", 0); ImplCycleCollectionTraverse(cb
, tmp->mPointersEnterLeaveHelper, "mPointersEnterLeaveHelper"
, 0); ImplCycleCollectionTraverse(cb, tmp->mDocument, "mDocument"
, 0); ImplCycleCollectionTraverse(cb, tmp->mIMEContentObserver
, "mIMEContentObserver", 0); ImplCycleCollectionTraverse(cb, tmp
->mAccessKeys, "mAccessKeys", 0); (void)tmp; return NS_OK;
}
576 mLastRightMouseDownInfo.mLastMouseDownContent,EventStateManager::cycleCollection EventStateManager::_cycleCollectorGlobal
; void EventStateManager::cycleCollection::Unlink(void* p) { EventStateManager
* tmp = DowncastCCParticipant<EventStateManager>(p); ImplCycleCollectionUnlink
(tmp->mCurrentTargetContent); ImplCycleCollectionUnlink(tmp
->mGestureDownContent); ImplCycleCollectionUnlink(tmp->
mGestureDownFrameOwner); ImplCycleCollectionUnlink(tmp->mLastLeftMouseDownInfo
.mLastMouseDownContent); ImplCycleCollectionUnlink(tmp->mLastMiddleMouseDownInfo
.mLastMouseDownContent); ImplCycleCollectionUnlink(tmp->mLastRightMouseDownInfo
.mLastMouseDownContent); ImplCycleCollectionUnlink(tmp->mActiveContent
); ImplCycleCollectionUnlink(tmp->mHoverContent); ImplCycleCollectionUnlink
(tmp->mURLTargetContent); ImplCycleCollectionUnlink(tmp->
mPopoverPointerDownTarget); ImplCycleCollectionUnlink(tmp->
mMouseEnterLeaveHelper); ImplCycleCollectionUnlink(tmp->mPointersEnterLeaveHelper
); ImplCycleCollectionUnlink(tmp->mDocument); ImplCycleCollectionUnlink
(tmp->mIMEContentObserver); ImplCycleCollectionUnlink(tmp->
mAccessKeys); tmp->ClearWeakReferences(); (void)tmp; } nsresult
EventStateManager::cycleCollection::TraverseNative( void* p,
nsCycleCollectionTraversalCallback& cb) { EventStateManager
* tmp = DowncastCCParticipant<EventStateManager>(p); cb
.DescribeRefCountedNode(tmp->mRefCnt.get(), "EventStateManager"
); ImplCycleCollectionTraverse(cb, tmp->mCurrentTargetContent
, "mCurrentTargetContent", 0); ImplCycleCollectionTraverse(cb
, tmp->mGestureDownContent, "mGestureDownContent", 0); ImplCycleCollectionTraverse
(cb, tmp->mGestureDownFrameOwner, "mGestureDownFrameOwner"
, 0); ImplCycleCollectionTraverse(cb, tmp->mLastLeftMouseDownInfo
.mLastMouseDownContent, "mLastLeftMouseDownInfo.mLastMouseDownContent"
, 0); ImplCycleCollectionTraverse(cb, tmp->mLastMiddleMouseDownInfo
.mLastMouseDownContent, "mLastMiddleMouseDownInfo.mLastMouseDownContent"
, 0); ImplCycleCollectionTraverse(cb, tmp->mLastRightMouseDownInfo
.mLastMouseDownContent, "mLastRightMouseDownInfo.mLastMouseDownContent"
, 0); ImplCycleCollectionTraverse(cb, tmp->mActiveContent,
"mActiveContent", 0); ImplCycleCollectionTraverse(cb, tmp->
mHoverContent, "mHoverContent", 0); ImplCycleCollectionTraverse
(cb, tmp->mURLTargetContent, "mURLTargetContent", 0); ImplCycleCollectionTraverse
(cb, tmp->mPopoverPointerDownTarget, "mPopoverPointerDownTarget"
, 0); ImplCycleCollectionTraverse(cb, tmp->mMouseEnterLeaveHelper
, "mMouseEnterLeaveHelper", 0); ImplCycleCollectionTraverse(cb
, tmp->mPointersEnterLeaveHelper, "mPointersEnterLeaveHelper"
, 0); ImplCycleCollectionTraverse(cb, tmp->mDocument, "mDocument"
, 0); ImplCycleCollectionTraverse(cb, tmp->mIMEContentObserver
, "mIMEContentObserver", 0); ImplCycleCollectionTraverse(cb, tmp
->mAccessKeys, "mAccessKeys", 0); (void)tmp; return NS_OK;
}
577 mActiveContent, mHoverContent, mURLTargetContent,EventStateManager::cycleCollection EventStateManager::_cycleCollectorGlobal
; void EventStateManager::cycleCollection::Unlink(void* p) { EventStateManager
* tmp = DowncastCCParticipant<EventStateManager>(p); ImplCycleCollectionUnlink
(tmp->mCurrentTargetContent); ImplCycleCollectionUnlink(tmp
->mGestureDownContent); ImplCycleCollectionUnlink(tmp->
mGestureDownFrameOwner); ImplCycleCollectionUnlink(tmp->mLastLeftMouseDownInfo
.mLastMouseDownContent); ImplCycleCollectionUnlink(tmp->mLastMiddleMouseDownInfo
.mLastMouseDownContent); ImplCycleCollectionUnlink(tmp->mLastRightMouseDownInfo
.mLastMouseDownContent); ImplCycleCollectionUnlink(tmp->mActiveContent
); ImplCycleCollectionUnlink(tmp->mHoverContent); ImplCycleCollectionUnlink
(tmp->mURLTargetContent); ImplCycleCollectionUnlink(tmp->
mPopoverPointerDownTarget); ImplCycleCollectionUnlink(tmp->
mMouseEnterLeaveHelper); ImplCycleCollectionUnlink(tmp->mPointersEnterLeaveHelper
); ImplCycleCollectionUnlink(tmp->mDocument); ImplCycleCollectionUnlink
(tmp->mIMEContentObserver); ImplCycleCollectionUnlink(tmp->
mAccessKeys); tmp->ClearWeakReferences(); (void)tmp; } nsresult
EventStateManager::cycleCollection::TraverseNative( void* p,
nsCycleCollectionTraversalCallback& cb) { EventStateManager
* tmp = DowncastCCParticipant<EventStateManager>(p); cb
.DescribeRefCountedNode(tmp->mRefCnt.get(), "EventStateManager"
); ImplCycleCollectionTraverse(cb, tmp->mCurrentTargetContent
, "mCurrentTargetContent", 0); ImplCycleCollectionTraverse(cb
, tmp->mGestureDownContent, "mGestureDownContent", 0); ImplCycleCollectionTraverse
(cb, tmp->mGestureDownFrameOwner, "mGestureDownFrameOwner"
, 0); ImplCycleCollectionTraverse(cb, tmp->mLastLeftMouseDownInfo
.mLastMouseDownContent, "mLastLeftMouseDownInfo.mLastMouseDownContent"
, 0); ImplCycleCollectionTraverse(cb, tmp->mLastMiddleMouseDownInfo
.mLastMouseDownContent, "mLastMiddleMouseDownInfo.mLastMouseDownContent"
, 0); ImplCycleCollectionTraverse(cb, tmp->mLastRightMouseDownInfo
.mLastMouseDownContent, "mLastRightMouseDownInfo.mLastMouseDownContent"
, 0); ImplCycleCollectionTraverse(cb, tmp->mActiveContent,
"mActiveContent", 0); ImplCycleCollectionTraverse(cb, tmp->
mHoverContent, "mHoverContent", 0); ImplCycleCollectionTraverse
(cb, tmp->mURLTargetContent, "mURLTargetContent", 0); ImplCycleCollectionTraverse
(cb, tmp->mPopoverPointerDownTarget, "mPopoverPointerDownTarget"
, 0); ImplCycleCollectionTraverse(cb, tmp->mMouseEnterLeaveHelper
, "mMouseEnterLeaveHelper", 0); ImplCycleCollectionTraverse(cb
, tmp->mPointersEnterLeaveHelper, "mPointersEnterLeaveHelper"
, 0); ImplCycleCollectionTraverse(cb, tmp->mDocument, "mDocument"
, 0); ImplCycleCollectionTraverse(cb, tmp->mIMEContentObserver
, "mIMEContentObserver", 0); ImplCycleCollectionTraverse(cb, tmp
->mAccessKeys, "mAccessKeys", 0); (void)tmp; return NS_OK;
}
578 mPopoverPointerDownTarget, mMouseEnterLeaveHelper,EventStateManager::cycleCollection EventStateManager::_cycleCollectorGlobal
; void EventStateManager::cycleCollection::Unlink(void* p) { EventStateManager
* tmp = DowncastCCParticipant<EventStateManager>(p); ImplCycleCollectionUnlink
(tmp->mCurrentTargetContent); ImplCycleCollectionUnlink(tmp
->mGestureDownContent); ImplCycleCollectionUnlink(tmp->
mGestureDownFrameOwner); ImplCycleCollectionUnlink(tmp->mLastLeftMouseDownInfo
.mLastMouseDownContent); ImplCycleCollectionUnlink(tmp->mLastMiddleMouseDownInfo
.mLastMouseDownContent); ImplCycleCollectionUnlink(tmp->mLastRightMouseDownInfo
.mLastMouseDownContent); ImplCycleCollectionUnlink(tmp->mActiveContent
); ImplCycleCollectionUnlink(tmp->mHoverContent); ImplCycleCollectionUnlink
(tmp->mURLTargetContent); ImplCycleCollectionUnlink(tmp->
mPopoverPointerDownTarget); ImplCycleCollectionUnlink(tmp->
mMouseEnterLeaveHelper); ImplCycleCollectionUnlink(tmp->mPointersEnterLeaveHelper
); ImplCycleCollectionUnlink(tmp->mDocument); ImplCycleCollectionUnlink
(tmp->mIMEContentObserver); ImplCycleCollectionUnlink(tmp->
mAccessKeys); tmp->ClearWeakReferences(); (void)tmp; } nsresult
EventStateManager::cycleCollection::TraverseNative( void* p,
nsCycleCollectionTraversalCallback& cb) { EventStateManager
* tmp = DowncastCCParticipant<EventStateManager>(p); cb
.DescribeRefCountedNode(tmp->mRefCnt.get(), "EventStateManager"
); ImplCycleCollectionTraverse(cb, tmp->mCurrentTargetContent
, "mCurrentTargetContent", 0); ImplCycleCollectionTraverse(cb
, tmp->mGestureDownContent, "mGestureDownContent", 0); ImplCycleCollectionTraverse
(cb, tmp->mGestureDownFrameOwner, "mGestureDownFrameOwner"
, 0); ImplCycleCollectionTraverse(cb, tmp->mLastLeftMouseDownInfo
.mLastMouseDownContent, "mLastLeftMouseDownInfo.mLastMouseDownContent"
, 0); ImplCycleCollectionTraverse(cb, tmp->mLastMiddleMouseDownInfo
.mLastMouseDownContent, "mLastMiddleMouseDownInfo.mLastMouseDownContent"
, 0); ImplCycleCollectionTraverse(cb, tmp->mLastRightMouseDownInfo
.mLastMouseDownContent, "mLastRightMouseDownInfo.mLastMouseDownContent"
, 0); ImplCycleCollectionTraverse(cb, tmp->mActiveContent,
"mActiveContent", 0); ImplCycleCollectionTraverse(cb, tmp->
mHoverContent, "mHoverContent", 0); ImplCycleCollectionTraverse
(cb, tmp->mURLTargetContent, "mURLTargetContent", 0); ImplCycleCollectionTraverse
(cb, tmp->mPopoverPointerDownTarget, "mPopoverPointerDownTarget"
, 0); ImplCycleCollectionTraverse(cb, tmp->mMouseEnterLeaveHelper
, "mMouseEnterLeaveHelper", 0); ImplCycleCollectionTraverse(cb
, tmp->mPointersEnterLeaveHelper, "mPointersEnterLeaveHelper"
, 0); ImplCycleCollectionTraverse(cb, tmp->mDocument, "mDocument"
, 0); ImplCycleCollectionTraverse(cb, tmp->mIMEContentObserver
, "mIMEContentObserver", 0); ImplCycleCollectionTraverse(cb, tmp
->mAccessKeys, "mAccessKeys", 0); (void)tmp; return NS_OK;
}
579 mPointersEnterLeaveHelper, mDocument,EventStateManager::cycleCollection EventStateManager::_cycleCollectorGlobal
; void EventStateManager::cycleCollection::Unlink(void* p) { EventStateManager
* tmp = DowncastCCParticipant<EventStateManager>(p); ImplCycleCollectionUnlink
(tmp->mCurrentTargetContent); ImplCycleCollectionUnlink(tmp
->mGestureDownContent); ImplCycleCollectionUnlink(tmp->
mGestureDownFrameOwner); ImplCycleCollectionUnlink(tmp->mLastLeftMouseDownInfo
.mLastMouseDownContent); ImplCycleCollectionUnlink(tmp->mLastMiddleMouseDownInfo
.mLastMouseDownContent); ImplCycleCollectionUnlink(tmp->mLastRightMouseDownInfo
.mLastMouseDownContent); ImplCycleCollectionUnlink(tmp->mActiveContent
); ImplCycleCollectionUnlink(tmp->mHoverContent); ImplCycleCollectionUnlink
(tmp->mURLTargetContent); ImplCycleCollectionUnlink(tmp->
mPopoverPointerDownTarget); ImplCycleCollectionUnlink(tmp->
mMouseEnterLeaveHelper); ImplCycleCollectionUnlink(tmp->mPointersEnterLeaveHelper
); ImplCycleCollectionUnlink(tmp->mDocument); ImplCycleCollectionUnlink
(tmp->mIMEContentObserver); ImplCycleCollectionUnlink(tmp->
mAccessKeys); tmp->ClearWeakReferences(); (void)tmp; } nsresult
EventStateManager::cycleCollection::TraverseNative( void* p,
nsCycleCollectionTraversalCallback& cb) { EventStateManager
* tmp = DowncastCCParticipant<EventStateManager>(p); cb
.DescribeRefCountedNode(tmp->mRefCnt.get(), "EventStateManager"
); ImplCycleCollectionTraverse(cb, tmp->mCurrentTargetContent
, "mCurrentTargetContent", 0); ImplCycleCollectionTraverse(cb
, tmp->mGestureDownContent, "mGestureDownContent", 0); ImplCycleCollectionTraverse
(cb, tmp->mGestureDownFrameOwner, "mGestureDownFrameOwner"
, 0); ImplCycleCollectionTraverse(cb, tmp->mLastLeftMouseDownInfo
.mLastMouseDownContent, "mLastLeftMouseDownInfo.mLastMouseDownContent"
, 0); ImplCycleCollectionTraverse(cb, tmp->mLastMiddleMouseDownInfo
.mLastMouseDownContent, "mLastMiddleMouseDownInfo.mLastMouseDownContent"
, 0); ImplCycleCollectionTraverse(cb, tmp->mLastRightMouseDownInfo
.mLastMouseDownContent, "mLastRightMouseDownInfo.mLastMouseDownContent"
, 0); ImplCycleCollectionTraverse(cb, tmp->mActiveContent,
"mActiveContent", 0); ImplCycleCollectionTraverse(cb, tmp->
mHoverContent, "mHoverContent", 0); ImplCycleCollectionTraverse
(cb, tmp->mURLTargetContent, "mURLTargetContent", 0); ImplCycleCollectionTraverse
(cb, tmp->mPopoverPointerDownTarget, "mPopoverPointerDownTarget"
, 0); ImplCycleCollectionTraverse(cb, tmp->mMouseEnterLeaveHelper
, "mMouseEnterLeaveHelper", 0); ImplCycleCollectionTraverse(cb
, tmp->mPointersEnterLeaveHelper, "mPointersEnterLeaveHelper"
, 0); ImplCycleCollectionTraverse(cb, tmp->mDocument, "mDocument"
, 0); ImplCycleCollectionTraverse(cb, tmp->mIMEContentObserver
, "mIMEContentObserver", 0); ImplCycleCollectionTraverse(cb, tmp
->mAccessKeys, "mAccessKeys", 0); (void)tmp; return NS_OK;
}
580 mIMEContentObserver, mAccessKeys)EventStateManager::cycleCollection EventStateManager::_cycleCollectorGlobal
; void EventStateManager::cycleCollection::Unlink(void* p) { EventStateManager
* tmp = DowncastCCParticipant<EventStateManager>(p); ImplCycleCollectionUnlink
(tmp->mCurrentTargetContent); ImplCycleCollectionUnlink(tmp
->mGestureDownContent); ImplCycleCollectionUnlink(tmp->
mGestureDownFrameOwner); ImplCycleCollectionUnlink(tmp->mLastLeftMouseDownInfo
.mLastMouseDownContent); ImplCycleCollectionUnlink(tmp->mLastMiddleMouseDownInfo
.mLastMouseDownContent); ImplCycleCollectionUnlink(tmp->mLastRightMouseDownInfo
.mLastMouseDownContent); ImplCycleCollectionUnlink(tmp->mActiveContent
); ImplCycleCollectionUnlink(tmp->mHoverContent); ImplCycleCollectionUnlink
(tmp->mURLTargetContent); ImplCycleCollectionUnlink(tmp->
mPopoverPointerDownTarget); ImplCycleCollectionUnlink(tmp->
mMouseEnterLeaveHelper); ImplCycleCollectionUnlink(tmp->mPointersEnterLeaveHelper
); ImplCycleCollectionUnlink(tmp->mDocument); ImplCycleCollectionUnlink
(tmp->mIMEContentObserver); ImplCycleCollectionUnlink(tmp->
mAccessKeys); tmp->ClearWeakReferences(); (void)tmp; } nsresult
EventStateManager::cycleCollection::TraverseNative( void* p,
nsCycleCollectionTraversalCallback& cb) { EventStateManager
* tmp = DowncastCCParticipant<EventStateManager>(p); cb
.DescribeRefCountedNode(tmp->mRefCnt.get(), "EventStateManager"
); ImplCycleCollectionTraverse(cb, tmp->mCurrentTargetContent
, "mCurrentTargetContent", 0); ImplCycleCollectionTraverse(cb
, tmp->mGestureDownContent, "mGestureDownContent", 0); ImplCycleCollectionTraverse
(cb, tmp->mGestureDownFrameOwner, "mGestureDownFrameOwner"
, 0); ImplCycleCollectionTraverse(cb, tmp->mLastLeftMouseDownInfo
.mLastMouseDownContent, "mLastLeftMouseDownInfo.mLastMouseDownContent"
, 0); ImplCycleCollectionTraverse(cb, tmp->mLastMiddleMouseDownInfo
.mLastMouseDownContent, "mLastMiddleMouseDownInfo.mLastMouseDownContent"
, 0); ImplCycleCollectionTraverse(cb, tmp->mLastRightMouseDownInfo
.mLastMouseDownContent, "mLastRightMouseDownInfo.mLastMouseDownContent"
, 0); ImplCycleCollectionTraverse(cb, tmp->mActiveContent,
"mActiveContent", 0); ImplCycleCollectionTraverse(cb, tmp->
mHoverContent, "mHoverContent", 0); ImplCycleCollectionTraverse
(cb, tmp->mURLTargetContent, "mURLTargetContent", 0); ImplCycleCollectionTraverse
(cb, tmp->mPopoverPointerDownTarget, "mPopoverPointerDownTarget"
, 0); ImplCycleCollectionTraverse(cb, tmp->mMouseEnterLeaveHelper
, "mMouseEnterLeaveHelper", 0); ImplCycleCollectionTraverse(cb
, tmp->mPointersEnterLeaveHelper, "mPointersEnterLeaveHelper"
, 0); ImplCycleCollectionTraverse(cb, tmp->mDocument, "mDocument"
, 0); ImplCycleCollectionTraverse(cb, tmp->mIMEContentObserver
, "mIMEContentObserver", 0); ImplCycleCollectionTraverse(cb, tmp
->mAccessKeys, "mAccessKeys", 0); (void)tmp; return NS_OK;
}
581
582void EventStateManager::ReleaseCurrentIMEContentObserver() {
583 if (mIMEContentObserver) {
584 mIMEContentObserver->DisconnectFromEventStateManager();
585 }
586 mIMEContentObserver = nullptr;
587}
588
589void EventStateManager::OnStartToObserveContent(
590 IMEContentObserver* aIMEContentObserver) {
591 if (mIMEContentObserver == aIMEContentObserver) {
592 return;
593 }
594 ReleaseCurrentIMEContentObserver();
595 mIMEContentObserver = aIMEContentObserver;
596}
597
598void EventStateManager::OnStopObservingContent(
599 IMEContentObserver* aIMEContentObserver) {
600 aIMEContentObserver->DisconnectFromEventStateManager();
601 NS_ENSURE_TRUE_VOID(mIMEContentObserver == aIMEContentObserver)do { if ((__builtin_expect(!!(!(mIMEContentObserver == aIMEContentObserver
)), 0))) { NS_DebugBreak(NS_DEBUG_WARNING, "NS_ENSURE_TRUE(" "mIMEContentObserver == aIMEContentObserver"
") failed", nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 601); return; } } while (false)
;
602 mIMEContentObserver = nullptr;
603}
604
605void EventStateManager::TryToFlushPendingNotificationsToIME() {
606 if (mIMEContentObserver) {
607 mIMEContentObserver->TryToFlushPendingNotifications(true);
608 }
609}
610
611static bool IsMessageMouseUserActivity(EventMessage aMessage) {
612 return aMessage == eMouseMove || aMessage == eMouseUp ||
613 aMessage == eMouseDown || aMessage == eMouseAuxClick ||
614 aMessage == eMouseDoubleClick || aMessage == eMouseClick ||
615 aMessage == eMouseActivate || aMessage == eMouseLongTap;
616}
617
618static bool IsMessageGamepadUserActivity(EventMessage aMessage) {
619 return aMessage == eGamepadButtonDown || aMessage == eGamepadButtonUp ||
620 aMessage == eGamepadAxisMove;
621}
622
623// static
624bool EventStateManager::IsKeyboardEventUserActivity(WidgetEvent* aEvent) {
625 // We ignore things that shouldn't cause popups, but also things that look
626 // like shortcut presses. In some obscure cases these may actually be
627 // website input, but any meaningful website will have other input anyway,
628 // and we can't very well tell whether shortcut input was supposed to be
629 // directed at chrome or the document.
630
631 WidgetKeyboardEvent* keyEvent = aEvent->AsKeyboardEvent();
632 // Access keys should be treated as page interaction.
633 if (keyEvent->ModifiersMatchWithAccessKey(AccessKeyType::eContent)) {
634 return true;
635 }
636 if (!keyEvent->CanTreatAsUserInput() || keyEvent->IsControl() ||
637 keyEvent->IsMeta() || keyEvent->IsAlt()) {
638 return false;
639 }
640 // Deal with function keys:
641 switch (keyEvent->mKeyNameIndex) {
642 case KEY_NAME_INDEX_F1:
643 case KEY_NAME_INDEX_F2:
644 case KEY_NAME_INDEX_F3:
645 case KEY_NAME_INDEX_F4:
646 case KEY_NAME_INDEX_F5:
647 case KEY_NAME_INDEX_F6:
648 case KEY_NAME_INDEX_F7:
649 case KEY_NAME_INDEX_F8:
650 case KEY_NAME_INDEX_F9:
651 case KEY_NAME_INDEX_F10:
652 case KEY_NAME_INDEX_F11:
653 case KEY_NAME_INDEX_F12:
654 case KEY_NAME_INDEX_F13:
655 case KEY_NAME_INDEX_F14:
656 case KEY_NAME_INDEX_F15:
657 case KEY_NAME_INDEX_F16:
658 case KEY_NAME_INDEX_F17:
659 case KEY_NAME_INDEX_F18:
660 case KEY_NAME_INDEX_F19:
661 case KEY_NAME_INDEX_F20:
662 case KEY_NAME_INDEX_F21:
663 case KEY_NAME_INDEX_F22:
664 case KEY_NAME_INDEX_F23:
665 case KEY_NAME_INDEX_F24:
666 return false;
667 default:
668 return true;
669 }
670}
671
672static void OnTypingInteractionEnded() {
673 // We don't consider a single keystroke to be typing.
674 if (gTypingInteractionKeyPresses > 1) {
675 gTypingInteraction.mInteractionCount += gTypingInteractionKeyPresses;
676 gTypingInteraction.mInteractionTimeInMilliseconds += static_cast<uint32_t>(
677 std::ceil((gTypingEndTime - gTypingStartTime).ToMilliseconds()));
678 }
679
680 gTypingInteractionKeyPresses = 0;
681 gTypingStartTime = TimeStamp();
682 gTypingEndTime = TimeStamp();
683}
684
685static void HandleKeyUpInteraction(WidgetKeyboardEvent* aKeyEvent) {
686 if (EventStateManager::IsKeyboardEventUserActivity(aKeyEvent)) {
687 TimeStamp now = TimeStamp::Now();
688 if (gTypingEndTime.IsNull()) {
689 gTypingEndTime = now;
690 }
691 TimeDuration delay = now - gTypingEndTime;
692 // Has it been too long since the last keystroke to be considered typing?
693 if (gTypingInteractionKeyPresses > 0 &&
694 delay >
695 TimeDuration::FromMilliseconds(
696 StaticPrefs::browser_places_interactions_typing_timeout_ms())) {
697 OnTypingInteractionEnded();
698 }
699 gTypingInteractionKeyPresses++;
700 if (gTypingStartTime.IsNull()) {
701 gTypingStartTime = now;
702 }
703 gTypingEndTime = now;
704 }
705}
706
707nsresult EventStateManager::PreHandleEvent(nsPresContext* aPresContext,
708 WidgetEvent* aEvent,
709 nsIFrame* aTargetFrame,
710 nsIContent* aTargetContent,
711 nsEventStatus* aStatus,
712 nsIContent* aOverrideClickTarget) {
713 NS_ENSURE_ARG_POINTER(aStatus)do { if ((__builtin_expect(!!(!(aStatus)), 0))) { NS_DebugBreak
(NS_DEBUG_WARNING, "NS_ENSURE_TRUE(" "aStatus" ") failed", nullptr
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 713); return NS_ERROR_INVALID_POINTER; } } while (false)
;
714 NS_ENSURE_ARG(aPresContext)do { if ((__builtin_expect(!!(!(aPresContext)), 0))) { NS_DebugBreak
(NS_DEBUG_WARNING, "NS_ENSURE_TRUE(" "aPresContext" ") failed"
, nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 714); return NS_ERROR_INVALID_ARG; } } while (false)
;
715 if (!aEvent) {
716 NS_ERROR("aEvent is null. This should never happen.")do { NS_DebugBreak(NS_DEBUG_ASSERTION, "aEvent is null. This should never happen."
, "Error", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 716); MOZ_PretendNoReturn(); } while (0)
;
717 return NS_ERROR_NULL_POINTER;
718 }
719
720 NS_WARNING_ASSERTION(do { if (!(!aTargetFrame || !aTargetFrame->GetContent() ||
aTargetFrame->GetContent() == aTargetContent || aTargetFrame
->GetContent()->GetFlattenedTreeParent() == aTargetContent
|| aTargetFrame->IsGeneratedContentFrame())) { NS_DebugBreak
(NS_DEBUG_WARNING, "aTargetFrame should be related with aTargetContent"
, "!aTargetFrame || !aTargetFrame->GetContent() || aTargetFrame->GetContent() == aTargetContent || aTargetFrame->GetContent()->GetFlattenedTreeParent() == aTargetContent || aTargetFrame->IsGeneratedContentFrame()"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 726); } } while (false)
721 !aTargetFrame || !aTargetFrame->GetContent() ||do { if (!(!aTargetFrame || !aTargetFrame->GetContent() ||
aTargetFrame->GetContent() == aTargetContent || aTargetFrame
->GetContent()->GetFlattenedTreeParent() == aTargetContent
|| aTargetFrame->IsGeneratedContentFrame())) { NS_DebugBreak
(NS_DEBUG_WARNING, "aTargetFrame should be related with aTargetContent"
, "!aTargetFrame || !aTargetFrame->GetContent() || aTargetFrame->GetContent() == aTargetContent || aTargetFrame->GetContent()->GetFlattenedTreeParent() == aTargetContent || aTargetFrame->IsGeneratedContentFrame()"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 726); } } while (false)
722 aTargetFrame->GetContent() == aTargetContent ||do { if (!(!aTargetFrame || !aTargetFrame->GetContent() ||
aTargetFrame->GetContent() == aTargetContent || aTargetFrame
->GetContent()->GetFlattenedTreeParent() == aTargetContent
|| aTargetFrame->IsGeneratedContentFrame())) { NS_DebugBreak
(NS_DEBUG_WARNING, "aTargetFrame should be related with aTargetContent"
, "!aTargetFrame || !aTargetFrame->GetContent() || aTargetFrame->GetContent() == aTargetContent || aTargetFrame->GetContent()->GetFlattenedTreeParent() == aTargetContent || aTargetFrame->IsGeneratedContentFrame()"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 726); } } while (false)
723 aTargetFrame->GetContent()->GetFlattenedTreeParent() ==do { if (!(!aTargetFrame || !aTargetFrame->GetContent() ||
aTargetFrame->GetContent() == aTargetContent || aTargetFrame
->GetContent()->GetFlattenedTreeParent() == aTargetContent
|| aTargetFrame->IsGeneratedContentFrame())) { NS_DebugBreak
(NS_DEBUG_WARNING, "aTargetFrame should be related with aTargetContent"
, "!aTargetFrame || !aTargetFrame->GetContent() || aTargetFrame->GetContent() == aTargetContent || aTargetFrame->GetContent()->GetFlattenedTreeParent() == aTargetContent || aTargetFrame->IsGeneratedContentFrame()"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 726); } } while (false)
724 aTargetContent ||do { if (!(!aTargetFrame || !aTargetFrame->GetContent() ||
aTargetFrame->GetContent() == aTargetContent || aTargetFrame
->GetContent()->GetFlattenedTreeParent() == aTargetContent
|| aTargetFrame->IsGeneratedContentFrame())) { NS_DebugBreak
(NS_DEBUG_WARNING, "aTargetFrame should be related with aTargetContent"
, "!aTargetFrame || !aTargetFrame->GetContent() || aTargetFrame->GetContent() == aTargetContent || aTargetFrame->GetContent()->GetFlattenedTreeParent() == aTargetContent || aTargetFrame->IsGeneratedContentFrame()"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 726); } } while (false)
725 aTargetFrame->IsGeneratedContentFrame(),do { if (!(!aTargetFrame || !aTargetFrame->GetContent() ||
aTargetFrame->GetContent() == aTargetContent || aTargetFrame
->GetContent()->GetFlattenedTreeParent() == aTargetContent
|| aTargetFrame->IsGeneratedContentFrame())) { NS_DebugBreak
(NS_DEBUG_WARNING, "aTargetFrame should be related with aTargetContent"
, "!aTargetFrame || !aTargetFrame->GetContent() || aTargetFrame->GetContent() == aTargetContent || aTargetFrame->GetContent()->GetFlattenedTreeParent() == aTargetContent || aTargetFrame->IsGeneratedContentFrame()"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 726); } } while (false)
726 "aTargetFrame should be related with aTargetContent")do { if (!(!aTargetFrame || !aTargetFrame->GetContent() ||
aTargetFrame->GetContent() == aTargetContent || aTargetFrame
->GetContent()->GetFlattenedTreeParent() == aTargetContent
|| aTargetFrame->IsGeneratedContentFrame())) { NS_DebugBreak
(NS_DEBUG_WARNING, "aTargetFrame should be related with aTargetContent"
, "!aTargetFrame || !aTargetFrame->GetContent() || aTargetFrame->GetContent() == aTargetContent || aTargetFrame->GetContent()->GetFlattenedTreeParent() == aTargetContent || aTargetFrame->IsGeneratedContentFrame()"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 726); } } while (false)
;
727#if DEBUG1
728 if (aTargetFrame && aTargetFrame->IsGeneratedContentFrame()) {
729 nsCOMPtr<nsIContent> targetContent;
730 aTargetFrame->GetContentForEvent(aEvent, getter_AddRefs(targetContent));
731 MOZ_ASSERT(aTargetContent == targetContent,do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aTargetContent == targetContent)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aTargetContent == targetContent
))), 0))) { do { } while (false); MOZ_ReportAssertionFailure(
"aTargetContent == targetContent" " (" "Unexpected target for generated content frame!"
")", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 732); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aTargetContent == targetContent"
") (" "Unexpected target for generated content frame!" ")");
do { *((volatile int*)__null) = 732; __attribute__((nomerge)
) ::abort(); } while (false); } } while (false)
732 "Unexpected target for generated content frame!")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aTargetContent == targetContent)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aTargetContent == targetContent
))), 0))) { do { } while (false); MOZ_ReportAssertionFailure(
"aTargetContent == targetContent" " (" "Unexpected target for generated content frame!"
")", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 732); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aTargetContent == targetContent"
") (" "Unexpected target for generated content frame!" ")");
do { *((volatile int*)__null) = 732; __attribute__((nomerge)
) ::abort(); } while (false); } } while (false)
;
733 }
734#endif
735
736 mCurrentTarget = aTargetFrame;
737 mCurrentTargetContent = nullptr;
738
739 // Do not take account eMouseEnterIntoWidget/ExitFromWidget so that loading
740 // a page when user is not active doesn't change the state to active.
741 WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent();
742 if (aEvent->IsTrusted() &&
743 ((mouseEvent && mouseEvent->IsReal() &&
744 IsMessageMouseUserActivity(mouseEvent->mMessage)) ||
745 aEvent->mClass == eWheelEventClass ||
746 aEvent->mClass == ePointerEventClass ||
747 aEvent->mClass == eTouchEventClass ||
748 aEvent->mClass == eKeyboardEventClass ||
749 (aEvent->mClass == eDragEventClass && aEvent->mMessage == eDrop) ||
750 IsMessageGamepadUserActivity(aEvent->mMessage))) {
751 if (gMouseOrKeyboardEventCounter == 0) {
752 nsCOMPtr<nsIObserverService> obs =
753 mozilla::services::GetObserverService();
754 if (obs) {
755 obs->NotifyObservers(nullptr, "user-interaction-active", nullptr);
756 UpdateUserActivityTimer();
757 }
758 }
759 ++gMouseOrKeyboardEventCounter;
760
761 nsCOMPtr<nsINode> node = aTargetContent;
762 if (node &&
763 ((aEvent->mMessage == eKeyUp && IsKeyboardEventUserActivity(aEvent)) ||
764 aEvent->mMessage == eMouseUp || aEvent->mMessage == eWheel ||
765 aEvent->mMessage == eTouchEnd || aEvent->mMessage == ePointerUp ||
766 aEvent->mMessage == eDrop)) {
767 Document* doc = node->OwnerDoc();
768 while (doc) {
769 doc->SetUserHasInteracted();
770 doc = nsContentUtils::IsChildOfSameType(doc)
771 ? doc->GetInProcessParentDocument()
772 : nullptr;
773 }
774 }
775 }
776
777 WheelTransaction::OnEvent(aEvent);
778
779 // Focus events don't necessarily need a frame.
780 if (!mCurrentTarget && !aTargetContent) {
781 NS_ERROR("mCurrentTarget and aTargetContent are null")do { NS_DebugBreak(NS_DEBUG_ASSERTION, "mCurrentTarget and aTargetContent are null"
, "Error", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 781); MOZ_PretendNoReturn(); } while (0)
;
782 return NS_ERROR_NULL_POINTER;
783 }
784#ifdef DEBUG1
785 if (aEvent->HasDragEventMessage() && PointerLockManager::IsLocked()) {
786 NS_ASSERTION(PointerLockManager::IsLocked(),do { if (!(PointerLockManager::IsLocked())) { NS_DebugBreak(NS_DEBUG_ASSERTION
, "Pointer is locked. Drag events should be suppressed when "
"the pointer is locked.", "PointerLockManager::IsLocked()", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 788); MOZ_PretendNoReturn(); } } while (0)
787 "Pointer is locked. Drag events should be suppressed when "do { if (!(PointerLockManager::IsLocked())) { NS_DebugBreak(NS_DEBUG_ASSERTION
, "Pointer is locked. Drag events should be suppressed when "
"the pointer is locked.", "PointerLockManager::IsLocked()", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 788); MOZ_PretendNoReturn(); } } while (0)
788 "the pointer is locked.")do { if (!(PointerLockManager::IsLocked())) { NS_DebugBreak(NS_DEBUG_ASSERTION
, "Pointer is locked. Drag events should be suppressed when "
"the pointer is locked.", "PointerLockManager::IsLocked()", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 788); MOZ_PretendNoReturn(); } } while (0)
;
789 }
790#endif
791 // Store last known screenPoint and clientPoint so pointer lock
792 // can use these values as constants.
793 if (aEvent->IsTrusted() &&
794 ((mouseEvent && mouseEvent->IsReal()) ||
795 aEvent->mClass == eWheelEventClass) &&
796 !PointerLockManager::IsLocked()) {
797 // XXX Probably doesn't matter much, but storing these in CSS pixels instead
798 // of device pixels means behavior can be a bit odd if you zoom while
799 // pointer-locked.
800 sLastScreenPoint =
801 Event::GetScreenCoords(aPresContext, aEvent, aEvent->mRefPoint)
802 .extract();
803 sLastClientPoint = Event::GetClientCoords(
804 aPresContext, aEvent, aEvent->mRefPoint, CSSIntPoint(0, 0));
805 }
806
807 *aStatus = nsEventStatus_eIgnore;
808
809 if (aEvent->mClass == eQueryContentEventClass) {
810 HandleQueryContentEvent(aEvent->AsQueryContentEvent());
811 return NS_OK;
812 }
813
814 WidgetTouchEvent* touchEvent = aEvent->AsTouchEvent();
815 if (touchEvent && mInTouchDrag) {
816 if (touchEvent->mMessage == eTouchMove) {
817 GenerateDragGesture(aPresContext, touchEvent);
818 } else {
819 mInTouchDrag = false;
820 StopTrackingDragGesture(true);
821 }
822 }
823
824 switch (aEvent->mMessage) {
825 case eContextMenu:
826 if (PointerLockManager::IsLocked()) {
827 return NS_ERROR_DOM_INVALID_STATE_ERR;
828 }
829 break;
830 case eMouseTouchDrag:
831 mInTouchDrag = true;
832 BeginTrackingDragGesture(aPresContext, mouseEvent, aTargetFrame);
833 break;
834 case eMouseDown: {
835 switch (mouseEvent->mButton) {
836 case MouseButton::ePrimary:
837 BeginTrackingDragGesture(aPresContext, mouseEvent, aTargetFrame);
838 mLastLeftMouseDownInfo.mClickCount = mouseEvent->mClickCount;
839 SetClickCount(mouseEvent, aStatus);
840 sNormalLMouseEventInProcess = true;
841 break;
842 case MouseButton::eMiddle:
843 mLastMiddleMouseDownInfo.mClickCount = mouseEvent->mClickCount;
844 SetClickCount(mouseEvent, aStatus);
845 break;
846 case MouseButton::eSecondary:
847 mLastRightMouseDownInfo.mClickCount = mouseEvent->mClickCount;
848 SetClickCount(mouseEvent, aStatus);
849 break;
850 }
851 NotifyTargetUserActivation(aEvent, aTargetContent);
852 break;
853 }
854 case eMouseUp: {
855 switch (mouseEvent->mButton) {
856 case MouseButton::ePrimary:
857 if (StaticPrefs::ui_click_hold_context_menus()) {
858 KillClickHoldTimer();
859 }
860 mInTouchDrag = false;
861 StopTrackingDragGesture(true);
862 sNormalLMouseEventInProcess = false;
863 // then fall through...
864 [[fallthrough]];
865 case MouseButton::eSecondary:
866 case MouseButton::eMiddle:
867 RefPtr<EventStateManager> esm =
868 ESMFromContentOrThis(aOverrideClickTarget);
869 esm->SetClickCount(mouseEvent, aStatus, aOverrideClickTarget);
870 break;
871 }
872 break;
873 }
874 case eMouseEnterIntoWidget:
875 PointerEventHandler::UpdateActivePointerState(mouseEvent, aTargetContent);
876 // In some cases on e10s eMouseEnterIntoWidget
877 // event was sent twice into child process of content.
878 // (From specific widget code (sending is not permanent) and
879 // from ESM::DispatchMouseOrPointerEvent (sending is permanent)).
880 // IsCrossProcessForwardingStopped() helps to suppress sending accidental
881 // event from widget code.
882 aEvent->StopCrossProcessForwarding();
883 break;
884 case eMouseExitFromWidget:
885 // If this is a remote frame, we receive eMouseExitFromWidget from the
886 // parent the mouse exits our content. Since the parent may update the
887 // cursor while the mouse is outside our frame, and since PuppetWidget
888 // caches the current cursor internally, re-entering our content (say from
889 // over a window edge) wont update the cursor if the cached value and the
890 // current cursor match. So when the mouse exits a remote frame, clear the
891 // cached widget cursor so a proper update will occur when the mouse
892 // re-enters.
893 if (XRE_IsContentProcess()) {
894 ClearCachedWidgetCursor(mCurrentTarget);
895 }
896
897 // IsCrossProcessForwardingStopped() helps to suppress double event
898 // sending into process of content. For more information see comment
899 // above, at eMouseEnterIntoWidget case.
900 aEvent->StopCrossProcessForwarding();
901
902 // If the event is not a top-level window or puppet widget exit, then it's
903 // not really an exit --- we may have traversed widget boundaries but
904 // we're still in our toplevel window or puppet widget.
905 if (mouseEvent->mExitFrom.value() !=
906 WidgetMouseEvent::ePlatformTopLevel &&
907 mouseEvent->mExitFrom.value() != WidgetMouseEvent::ePuppet) {
908 // Treat it as a synthetic move so we don't generate spurious
909 // "exit" or "move" events. Any necessary "out" or "over" events
910 // will be generated by GenerateMouseEnterExit
911 mouseEvent->mMessage = eMouseMove;
912 mouseEvent->mReason = WidgetMouseEvent::eSynthesized;
913 // then fall through...
914 } else {
915 MOZ_ASSERT_IF(XRE_IsParentProcess(),do { if (XRE_IsParentProcess()) { do { static_assert( mozilla
::detail::AssertionConditionType<decltype(mouseEvent->mExitFrom
.value() == WidgetMouseEvent::ePlatformTopLevel)>::isValid
, "invalid assertion condition"); if ((__builtin_expect(!!(!(
!!(mouseEvent->mExitFrom.value() == WidgetMouseEvent::ePlatformTopLevel
))), 0))) { do { } while (false); MOZ_ReportAssertionFailure(
"mouseEvent->mExitFrom.value() == WidgetMouseEvent::ePlatformTopLevel"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 917); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mouseEvent->mExitFrom.value() == WidgetMouseEvent::ePlatformTopLevel"
")"); do { *((volatile int*)__null) = 917; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
916 mouseEvent->mExitFrom.value() ==do { if (XRE_IsParentProcess()) { do { static_assert( mozilla
::detail::AssertionConditionType<decltype(mouseEvent->mExitFrom
.value() == WidgetMouseEvent::ePlatformTopLevel)>::isValid
, "invalid assertion condition"); if ((__builtin_expect(!!(!(
!!(mouseEvent->mExitFrom.value() == WidgetMouseEvent::ePlatformTopLevel
))), 0))) { do { } while (false); MOZ_ReportAssertionFailure(
"mouseEvent->mExitFrom.value() == WidgetMouseEvent::ePlatformTopLevel"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 917); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mouseEvent->mExitFrom.value() == WidgetMouseEvent::ePlatformTopLevel"
")"); do { *((volatile int*)__null) = 917; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
917 WidgetMouseEvent::ePlatformTopLevel)do { if (XRE_IsParentProcess()) { do { static_assert( mozilla
::detail::AssertionConditionType<decltype(mouseEvent->mExitFrom
.value() == WidgetMouseEvent::ePlatformTopLevel)>::isValid
, "invalid assertion condition"); if ((__builtin_expect(!!(!(
!!(mouseEvent->mExitFrom.value() == WidgetMouseEvent::ePlatformTopLevel
))), 0))) { do { } while (false); MOZ_ReportAssertionFailure(
"mouseEvent->mExitFrom.value() == WidgetMouseEvent::ePlatformTopLevel"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 917); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mouseEvent->mExitFrom.value() == WidgetMouseEvent::ePlatformTopLevel"
")"); do { *((volatile int*)__null) = 917; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
;
918 MOZ_ASSERT_IF(XRE_IsContentProcess(), mouseEvent->mExitFrom.value() ==do { if (XRE_IsContentProcess()) { do { static_assert( mozilla
::detail::AssertionConditionType<decltype(mouseEvent->mExitFrom
.value() == WidgetMouseEvent::ePuppet)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mouseEvent->mExitFrom.value
() == WidgetMouseEvent::ePuppet))), 0))) { do { } while (false
); MOZ_ReportAssertionFailure("mouseEvent->mExitFrom.value() == WidgetMouseEvent::ePuppet"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 919); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mouseEvent->mExitFrom.value() == WidgetMouseEvent::ePuppet"
")"); do { *((volatile int*)__null) = 919; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
919 WidgetMouseEvent::ePuppet)do { if (XRE_IsContentProcess()) { do { static_assert( mozilla
::detail::AssertionConditionType<decltype(mouseEvent->mExitFrom
.value() == WidgetMouseEvent::ePuppet)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mouseEvent->mExitFrom.value
() == WidgetMouseEvent::ePuppet))), 0))) { do { } while (false
); MOZ_ReportAssertionFailure("mouseEvent->mExitFrom.value() == WidgetMouseEvent::ePuppet"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 919); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mouseEvent->mExitFrom.value() == WidgetMouseEvent::ePuppet"
")"); do { *((volatile int*)__null) = 919; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
;
920 // We should synthetize corresponding pointer events
921 GeneratePointerEnterExit(ePointerLeave, mouseEvent);
922 GenerateMouseEnterExit(mouseEvent);
923 // This is really an exit and should stop here
924 aEvent->mMessage = eVoidEvent;
925 break;
926 }
927 [[fallthrough]];
928 case eMouseMove:
929 case ePointerDown:
930 if (aEvent->mMessage == ePointerDown) {
931 PointerEventHandler::UpdateActivePointerState(mouseEvent,
932 aTargetContent);
933 PointerEventHandler::ImplicitlyCapturePointer(aTargetFrame, aEvent);
934 if (mouseEvent->mInputSource != MouseEvent_Binding::MOZ_SOURCE_TOUCH) {
935 NotifyTargetUserActivation(aEvent, aTargetContent);
936 }
937
938 LightDismissOpenPopovers(aEvent, aTargetContent);
939 }
940 [[fallthrough]];
941 case ePointerMove: {
942 if (!mInTouchDrag &&
943 PointerEventHandler::IsDragAndDropEnabled(*mouseEvent)) {
944 GenerateDragGesture(aPresContext, mouseEvent);
945 }
946 // on the Mac, GenerateDragGesture() may not return until the drag
947 // has completed and so |aTargetFrame| may have been deleted (moving
948 // a bookmark, for example). If this is the case, however, we know
949 // that ClearFrameRefs() has been called and it cleared out
950 // |mCurrentTarget|. As a result, we should pass |mCurrentTarget|
951 // into UpdateCursor().
952 UpdateCursor(aPresContext, mouseEvent, mCurrentTarget, aStatus);
953
954 UpdateLastRefPointOfMouseEvent(mouseEvent);
955 if (PointerLockManager::IsLocked()) {
956 ResetPointerToWindowCenterWhilePointerLocked(mouseEvent);
957 }
958 UpdateLastPointerPosition(mouseEvent);
959
960 GenerateMouseEnterExit(mouseEvent);
961 // Flush pending layout changes, so that later mouse move events
962 // will go to the right nodes.
963 FlushLayout(aPresContext);
964 break;
965 }
966 case ePointerUp:
967 LightDismissOpenPopovers(aEvent, aTargetContent);
968 break;
969 case ePointerGotCapture:
970 GenerateMouseEnterExit(mouseEvent);
971 break;
972 case eDragStart:
973 if (StaticPrefs::ui_click_hold_context_menus()) {
974 // an external drag gesture event came in, not generated internally
975 // by Gecko. Make sure we get rid of the click-hold timer.
976 KillClickHoldTimer();
977 }
978 break;
979 case eDragOver: {
980 WidgetDragEvent* dragEvent = aEvent->AsDragEvent();
981 MOZ_ASSERT(dragEvent)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(dragEvent)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(dragEvent))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("dragEvent", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 981); AnnotateMozCrashReason("MOZ_ASSERT" "(" "dragEvent" ")"
); do { *((volatile int*)__null) = 981; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
982 if (dragEvent->mFlags.mIsSynthesizedForTests) {
983 dragEvent->InitDropEffectForTests();
984 }
985 // Send the enter/exit events before eDrop.
986 GenerateDragDropEnterExit(aPresContext, dragEvent);
987 break;
988 }
989 case eDrop:
990 if (aEvent->mFlags.mIsSynthesizedForTests) {
991 MOZ_ASSERT(aEvent->AsDragEvent())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aEvent->AsDragEvent())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aEvent->AsDragEvent()))),
0))) { do { } while (false); MOZ_ReportAssertionFailure("aEvent->AsDragEvent()"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 991); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aEvent->AsDragEvent()"
")"); do { *((volatile int*)__null) = 991; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
992 aEvent->AsDragEvent()->InitDropEffectForTests();
993 }
994 break;
995
996 case eKeyPress: {
997 WidgetKeyboardEvent* keyEvent = aEvent->AsKeyboardEvent();
998 if (keyEvent->ModifiersMatchWithAccessKey(AccessKeyType::eChrome) ||
999 keyEvent->ModifiersMatchWithAccessKey(AccessKeyType::eContent)) {
1000 // If the eKeyPress event will be sent to a remote process, this
1001 // process needs to wait reply from the remote process for checking if
1002 // preceding eKeyDown event is consumed. If preceding eKeyDown event
1003 // is consumed in the remote process, BrowserChild won't send the event
1004 // back to this process. So, only when this process receives a reply
1005 // eKeyPress event in BrowserParent, we should handle accesskey in this
1006 // process.
1007 if (IsTopLevelRemoteTarget(GetFocusedElement())) {
1008 // However, if there is no accesskey target for the key combination,
1009 // we don't need to wait reply from the remote process. Otherwise,
1010 // Mark the event as waiting reply from remote process and stop
1011 // propagation in this process.
1012 if (CheckIfEventMatchesAccessKey(keyEvent, aPresContext)) {
1013 keyEvent->StopPropagation();
1014 keyEvent->MarkAsWaitingReplyFromRemoteProcess();
1015 }
1016 }
1017 // If the event target is in this process, we can handle accesskey now
1018 // since if preceding eKeyDown event was consumed, eKeyPress event
1019 // won't be dispatched by widget. So, coming eKeyPress event means
1020 // that the preceding eKeyDown event wasn't consumed in this case.
1021 else {
1022 AutoTArray<uint32_t, 10> accessCharCodes;
1023 keyEvent->GetAccessKeyCandidates(accessCharCodes);
1024
1025 if (HandleAccessKey(keyEvent, aPresContext, accessCharCodes)) {
1026 *aStatus = nsEventStatus_eConsumeNoDefault;
1027 }
1028 }
1029 }
1030 }
1031 // then fall through...
1032 [[fallthrough]];
1033 case eKeyDown:
1034 if (aEvent->mMessage == eKeyDown) {
1035 NotifyTargetUserActivation(aEvent, aTargetContent);
1036 }
1037 [[fallthrough]];
1038 case eKeyUp: {
1039 Element* element = GetFocusedElement();
1040 if (element) {
1041 mCurrentTargetContent = element;
1042 }
1043
1044 // NOTE: Don't refer TextComposition::IsComposing() since UI Events
1045 // defines that KeyboardEvent.isComposing is true when it's
1046 // dispatched after compositionstart and compositionend.
1047 // TextComposition::IsComposing() is false even before
1048 // compositionend if there is no composing string.
1049 // And also don't expose other document's composition state.
1050 // A native IME context is typically shared by multiple documents.
1051 // So, don't use GetTextCompositionFor(nsIWidget*) here.
1052 RefPtr<TextComposition> composition =
1053 IMEStateManager::GetTextCompositionFor(aPresContext);
1054 aEvent->AsKeyboardEvent()->mIsComposing = !!composition;
1055
1056 // Widget may need to perform default action for specific keyboard
1057 // event if it's not consumed. In this case, widget has already marked
1058 // the event as "waiting reply from remote process". However, we need
1059 // to reset it if the target (focused content) isn't in a remote process
1060 // because PresShell needs to check if it's marked as so before
1061 // dispatching events into the DOM tree.
1062 if (aEvent->IsWaitingReplyFromRemoteProcess() &&
1063 !aEvent->PropagationStopped() && !IsTopLevelRemoteTarget(element)) {
1064 aEvent->ResetWaitingReplyFromRemoteProcessState();
1065 }
1066 } break;
1067 case eWheel:
1068 case eWheelOperationStart:
1069 case eWheelOperationEnd: {
1070 NS_ASSERTION(aEvent->IsTrusted(),do { if (!(aEvent->IsTrusted())) { NS_DebugBreak(NS_DEBUG_ASSERTION
, "Untrusted wheel event shouldn't be here", "aEvent->IsTrusted()"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1071); MOZ_PretendNoReturn(); } } while (0)
1071 "Untrusted wheel event shouldn't be here")do { if (!(aEvent->IsTrusted())) { NS_DebugBreak(NS_DEBUG_ASSERTION
, "Untrusted wheel event shouldn't be here", "aEvent->IsTrusted()"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1071); MOZ_PretendNoReturn(); } } while (0)
;
1072 using DeltaModeCheckingState = WidgetWheelEvent::DeltaModeCheckingState;
1073
1074 if (Element* element = GetFocusedElement()) {
1075 mCurrentTargetContent = element;
1076 }
1077
1078 if (aEvent->mMessage != eWheel) {
1079 break;
1080 }
1081
1082 WidgetWheelEvent* wheelEvent = aEvent->AsWheelEvent();
1083 WheelPrefs::GetInstance()->ApplyUserPrefsToDelta(wheelEvent);
1084
1085 // If we won't dispatch a DOM event for this event, nothing to do anymore.
1086 if (!wheelEvent->IsAllowedToDispatchDOMEvent()) {
1087 break;
1088 }
1089
1090 if (StaticPrefs::dom_event_wheel_deltaMode_lines_always_disabled()) {
1091 wheelEvent->mDeltaModeCheckingState = DeltaModeCheckingState::Unchecked;
1092 } else if (ShouldAlwaysUseLineDeltas()) {
1093 wheelEvent->mDeltaModeCheckingState = DeltaModeCheckingState::Checked;
1094 } else {
1095 wheelEvent->mDeltaModeCheckingState = DeltaModeCheckingState::Unknown;
1096 }
1097
1098 // Init lineOrPageDelta values for line scroll events for some devices
1099 // on some platforms which might dispatch wheel events which don't
1100 // have lineOrPageDelta values. And also, if delta values are
1101 // customized by prefs, this recomputes them.
1102 DeltaAccumulator::GetInstance()->InitLineOrPageDelta(aTargetFrame, this,
1103 wheelEvent);
1104 } break;
1105 case eSetSelection: {
1106 RefPtr<Element> focuedElement = GetFocusedElement();
1107 IMEStateManager::HandleSelectionEvent(aPresContext, focuedElement,
1108 aEvent->AsSelectionEvent());
1109 break;
1110 }
1111 case eContentCommandCut:
1112 case eContentCommandCopy:
1113 case eContentCommandPaste:
1114 case eContentCommandDelete:
1115 case eContentCommandUndo:
1116 case eContentCommandRedo:
1117 case eContentCommandPasteTransferable:
1118 case eContentCommandLookUpDictionary:
1119 DoContentCommandEvent(aEvent->AsContentCommandEvent());
1120 break;
1121 case eContentCommandInsertText:
1122 DoContentCommandInsertTextEvent(aEvent->AsContentCommandEvent());
1123 break;
1124 case eContentCommandScroll:
1125 DoContentCommandScrollEvent(aEvent->AsContentCommandEvent());
1126 break;
1127 case eCompositionStart:
1128 if (aEvent->IsTrusted()) {
1129 // If the event is trusted event, set the selected text to data of
1130 // composition event.
1131 WidgetCompositionEvent* compositionEvent = aEvent->AsCompositionEvent();
1132 WidgetQueryContentEvent querySelectedTextEvent(
1133 true, eQuerySelectedText, compositionEvent->mWidget);
1134 HandleQueryContentEvent(&querySelectedTextEvent);
1135 if (querySelectedTextEvent.FoundSelection()) {
1136 compositionEvent->mData = querySelectedTextEvent.mReply->DataRef();
1137 }
1138 NS_ASSERTION(querySelectedTextEvent.Succeeded(),do { if (!(querySelectedTextEvent.Succeeded())) { NS_DebugBreak
(NS_DEBUG_ASSERTION, "Failed to get selected text", "querySelectedTextEvent.Succeeded()"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1139); MOZ_PretendNoReturn(); } } while (0)
1139 "Failed to get selected text")do { if (!(querySelectedTextEvent.Succeeded())) { NS_DebugBreak
(NS_DEBUG_ASSERTION, "Failed to get selected text", "querySelectedTextEvent.Succeeded()"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1139); MOZ_PretendNoReturn(); } } while (0)
;
1140 }
1141 break;
1142 case eTouchStart:
1143 SetGestureDownPoint(aEvent->AsTouchEvent());
1144 break;
1145 case eTouchEnd:
1146 NotifyTargetUserActivation(aEvent, aTargetContent);
1147 break;
1148 default:
1149 break;
1150 }
1151 return NS_OK;
1152}
1153
1154// Returns true if this event is likely an user activation for a link or
1155// a link-like button, where modifier keys are likely be used for controlling
1156// where the link is opened.
1157//
1158// The modifiers associated with the user activation is used for controlling
1159// where the `window.open` is opened into.
1160static bool CanReflectModifiersToUserActivation(WidgetInputEvent* aEvent) {
1161 MOZ_ASSERT(aEvent->mMessage == eKeyDown || aEvent->mMessage == eMouseDown ||do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aEvent->mMessage == eKeyDown || aEvent->mMessage
== eMouseDown || aEvent->mMessage == ePointerDown || aEvent
->mMessage == eTouchEnd)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aEvent->mMessage == eKeyDown
|| aEvent->mMessage == eMouseDown || aEvent->mMessage ==
ePointerDown || aEvent->mMessage == eTouchEnd))), 0))) { do
{ } while (false); MOZ_ReportAssertionFailure("aEvent->mMessage == eKeyDown || aEvent->mMessage == eMouseDown || aEvent->mMessage == ePointerDown || aEvent->mMessage == eTouchEnd"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1162); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aEvent->mMessage == eKeyDown || aEvent->mMessage == eMouseDown || aEvent->mMessage == ePointerDown || aEvent->mMessage == eTouchEnd"
")"); do { *((volatile int*)__null) = 1162; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
1162 aEvent->mMessage == ePointerDown || aEvent->mMessage == eTouchEnd)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aEvent->mMessage == eKeyDown || aEvent->mMessage
== eMouseDown || aEvent->mMessage == ePointerDown || aEvent
->mMessage == eTouchEnd)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aEvent->mMessage == eKeyDown
|| aEvent->mMessage == eMouseDown || aEvent->mMessage ==
ePointerDown || aEvent->mMessage == eTouchEnd))), 0))) { do
{ } while (false); MOZ_ReportAssertionFailure("aEvent->mMessage == eKeyDown || aEvent->mMessage == eMouseDown || aEvent->mMessage == ePointerDown || aEvent->mMessage == eTouchEnd"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1162); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aEvent->mMessage == eKeyDown || aEvent->mMessage == eMouseDown || aEvent->mMessage == ePointerDown || aEvent->mMessage == eTouchEnd"
")"); do { *((volatile int*)__null) = 1162; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1163
1164 WidgetKeyboardEvent* keyEvent = aEvent->AsKeyboardEvent();
1165 if (keyEvent) {
1166 return keyEvent->CanReflectModifiersToUserActivation();
1167 }
1168
1169 return true;
1170}
1171
1172void EventStateManager::NotifyTargetUserActivation(WidgetEvent* aEvent,
1173 nsIContent* aTargetContent) {
1174 if (!aEvent->IsTrusted()) {
1175 return;
1176 }
1177
1178 WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent();
1179 if (mouseEvent && !mouseEvent->IsReal()) {
1180 return;
1181 }
1182
1183 nsCOMPtr<nsINode> node = aTargetContent;
1184 if (!node) {
1185 return;
1186 }
1187
1188 Document* doc = node->OwnerDoc();
1189 if (!doc) {
1190 return;
1191 }
1192
1193 // Don't gesture activate for key events for keys which are likely
1194 // to be interaction with the browser, OS.
1195 WidgetKeyboardEvent* keyEvent = aEvent->AsKeyboardEvent();
1196 if (keyEvent && !keyEvent->CanUserGestureActivateTarget()) {
1197 return;
1198 }
1199
1200 // Touch gestures that end outside the drag target were touches that turned
1201 // into scroll/pan/swipe actions. We don't want to gesture activate on such
1202 // actions, we want to only gesture activate on touches that are taps.
1203 // That is, touches that end in roughly the same place that they started.
1204 if (aEvent->mMessage == eTouchEnd && aEvent->AsTouchEvent() &&
1205 IsEventOutsideDragThreshold(aEvent->AsTouchEvent())) {
1206 return;
1207 }
1208
1209 // Do not treat the click on scrollbar as a user interaction with the web
1210 // content.
1211 if (StaticPrefs::dom_user_activation_ignore_scrollbars() &&
1212 (aEvent->mMessage == eMouseDown || aEvent->mMessage == ePointerDown) &&
1213 aTargetContent->IsInNativeAnonymousSubtree()) {
1214 nsIContent* current = aTargetContent;
1215 do {
1216 nsIContent* root = current->GetClosestNativeAnonymousSubtreeRoot();
1217 if (!root) {
1218 break;
1219 }
1220 if (root->IsXULElement(nsGkAtoms::scrollbar)) {
1221 return;
1222 }
1223 current = root->GetParent();
1224 } while (current);
1225 }
1226
1227 MOZ_ASSERT(aEvent->mMessage == eKeyDown || aEvent->mMessage == eMouseDown ||do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aEvent->mMessage == eKeyDown || aEvent->mMessage
== eMouseDown || aEvent->mMessage == ePointerDown || aEvent
->mMessage == eTouchEnd)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aEvent->mMessage == eKeyDown
|| aEvent->mMessage == eMouseDown || aEvent->mMessage ==
ePointerDown || aEvent->mMessage == eTouchEnd))), 0))) { do
{ } while (false); MOZ_ReportAssertionFailure("aEvent->mMessage == eKeyDown || aEvent->mMessage == eMouseDown || aEvent->mMessage == ePointerDown || aEvent->mMessage == eTouchEnd"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1228); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aEvent->mMessage == eKeyDown || aEvent->mMessage == eMouseDown || aEvent->mMessage == ePointerDown || aEvent->mMessage == eTouchEnd"
")"); do { *((volatile int*)__null) = 1228; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
1228 aEvent->mMessage == ePointerDown || aEvent->mMessage == eTouchEnd)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aEvent->mMessage == eKeyDown || aEvent->mMessage
== eMouseDown || aEvent->mMessage == ePointerDown || aEvent
->mMessage == eTouchEnd)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aEvent->mMessage == eKeyDown
|| aEvent->mMessage == eMouseDown || aEvent->mMessage ==
ePointerDown || aEvent->mMessage == eTouchEnd))), 0))) { do
{ } while (false); MOZ_ReportAssertionFailure("aEvent->mMessage == eKeyDown || aEvent->mMessage == eMouseDown || aEvent->mMessage == ePointerDown || aEvent->mMessage == eTouchEnd"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1228); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aEvent->mMessage == eKeyDown || aEvent->mMessage == eMouseDown || aEvent->mMessage == ePointerDown || aEvent->mMessage == eTouchEnd"
")"); do { *((volatile int*)__null) = 1228; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1229 UserActivation::Modifiers modifiers;
1230 if (WidgetInputEvent* inputEvent = aEvent->AsInputEvent()) {
1231 if (CanReflectModifiersToUserActivation(inputEvent)) {
1232 if (inputEvent->IsShift()) {
1233 modifiers.SetShift();
1234 }
1235 if (inputEvent->IsMeta()) {
1236 modifiers.SetMeta();
1237 }
1238 if (inputEvent->IsControl()) {
1239 modifiers.SetControl();
1240 }
1241 if (inputEvent->IsAlt()) {
1242 modifiers.SetAlt();
1243 }
1244 }
1245 }
1246 doc->NotifyUserGestureActivation(modifiers);
1247}
1248
1249// https://html.spec.whatwg.org/multipage/popover.html#popover-light-dismiss
1250void EventStateManager::LightDismissOpenPopovers(WidgetEvent* aEvent,
1251 nsIContent* aTargetContent) {
1252 MOZ_ASSERT(aEvent->mMessage == ePointerDown || aEvent->mMessage == ePointerUp,do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aEvent->mMessage == ePointerDown || aEvent->mMessage
== ePointerUp)>::isValid, "invalid assertion condition");
if ((__builtin_expect(!!(!(!!(aEvent->mMessage == ePointerDown
|| aEvent->mMessage == ePointerUp))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("aEvent->mMessage == ePointerDown || aEvent->mMessage == ePointerUp"
" (" "Light dismiss must be called for pointer up/down only"
")", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1253); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aEvent->mMessage == ePointerDown || aEvent->mMessage == ePointerUp"
") (" "Light dismiss must be called for pointer up/down only"
")"); do { *((volatile int*)__null) = 1253; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
1253 "Light dismiss must be called for pointer up/down only")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aEvent->mMessage == ePointerDown || aEvent->mMessage
== ePointerUp)>::isValid, "invalid assertion condition");
if ((__builtin_expect(!!(!(!!(aEvent->mMessage == ePointerDown
|| aEvent->mMessage == ePointerUp))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("aEvent->mMessage == ePointerDown || aEvent->mMessage == ePointerUp"
" (" "Light dismiss must be called for pointer up/down only"
")", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1253); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aEvent->mMessage == ePointerDown || aEvent->mMessage == ePointerUp"
") (" "Light dismiss must be called for pointer up/down only"
")"); do { *((volatile int*)__null) = 1253; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1254
1255 if (!StaticPrefs::dom_element_popover_enabled() || !aEvent->IsTrusted() ||
1256 !aTargetContent) {
1257 return;
1258 }
1259
1260 Element* topmostPopover = aTargetContent->OwnerDoc()->GetTopmostAutoPopover();
1261 if (!topmostPopover) {
1262 return;
1263 }
1264
1265 // Pointerdown: set document's popover pointerdown target to the result of
1266 // running topmost clicked popover given target.
1267 if (aEvent->mMessage == ePointerDown) {
1268 mPopoverPointerDownTarget = aTargetContent->GetTopmostClickedPopover();
1269 return;
1270 }
1271
1272 // Pointerup: hide open popovers.
1273 RefPtr<nsINode> ancestor = aTargetContent->GetTopmostClickedPopover();
1274 bool sameTarget = mPopoverPointerDownTarget == ancestor;
1275 mPopoverPointerDownTarget = nullptr;
1276 if (!sameTarget) {
1277 return;
1278 }
1279
1280 if (!ancestor) {
1281 ancestor = aTargetContent->OwnerDoc();
1282 }
1283 RefPtr<Document> doc(ancestor->OwnerDoc());
1284 doc->HideAllPopoversUntil(*ancestor, false, true);
1285}
1286
1287already_AddRefed<EventStateManager> EventStateManager::ESMFromContentOrThis(
1288 nsIContent* aContent) {
1289 if (aContent) {
1290 PresShell* presShell = aContent->OwnerDoc()->GetPresShell();
1291 if (presShell) {
1292 nsPresContext* prescontext = presShell->GetPresContext();
1293 if (prescontext) {
1294 RefPtr<EventStateManager> esm = prescontext->EventStateManager();
1295 if (esm) {
1296 return esm.forget();
1297 }
1298 }
1299 }
1300 }
1301
1302 RefPtr<EventStateManager> esm = this;
1303 return esm.forget();
1304}
1305
1306EventStateManager::LastMouseDownInfo& EventStateManager::GetLastMouseDownInfo(
1307 int16_t aButton) {
1308 switch (aButton) {
1309 case MouseButton::ePrimary:
1310 return mLastLeftMouseDownInfo;
1311 case MouseButton::eMiddle:
1312 return mLastMiddleMouseDownInfo;
1313 case MouseButton::eSecondary:
1314 return mLastRightMouseDownInfo;
1315 default:
1316 MOZ_ASSERT_UNREACHABLE("This button shouldn't use this method")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(false)>::isValid, "invalid assertion condition");
if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("false" " (" "MOZ_ASSERT_UNREACHABLE: "
"This button shouldn't use this method" ")", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1316); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") ("
"MOZ_ASSERT_UNREACHABLE: " "This button shouldn't use this method"
")"); do { *((volatile int*)__null) = 1316; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1317 return mLastLeftMouseDownInfo;
1318 }
1319}
1320
1321void EventStateManager::HandleQueryContentEvent(
1322 WidgetQueryContentEvent* aEvent) {
1323 switch (aEvent->mMessage) {
1324 case eQuerySelectedText:
1325 case eQueryTextContent:
1326 case eQueryCaretRect:
1327 case eQueryTextRect:
1328 case eQueryEditorRect:
1329 if (!IsTargetCrossProcess(aEvent)) {
1330 break;
1331 }
1332 // Will not be handled locally, remote the event
1333 GetCrossProcessTarget()->HandleQueryContentEvent(*aEvent);
1334 return;
1335 // Following events have not been supported in e10s mode yet.
1336 case eQueryContentState:
1337 case eQuerySelectionAsTransferable:
1338 case eQueryCharacterAtPoint:
1339 case eQueryDOMWidgetHittest:
1340 case eQueryTextRectArray:
1341 break;
1342 default:
1343 return;
1344 }
1345
1346 // If there is an IMEContentObserver, we need to handle QueryContentEvent
1347 // with it.
1348 if (mIMEContentObserver) {
1349 RefPtr<IMEContentObserver> contentObserver = mIMEContentObserver;
1350 contentObserver->HandleQueryContentEvent(aEvent);
1351 return;
1352 }
1353
1354 ContentEventHandler handler(mPresContext);
1355 handler.HandleQueryContentEvent(aEvent);
1356}
1357
1358static AccessKeyType GetAccessKeyTypeFor(nsISupports* aDocShell) {
1359 nsCOMPtr<nsIDocShellTreeItem> treeItem(do_QueryInterface(aDocShell));
1360 if (!treeItem) {
1361 return AccessKeyType::eNone;
1362 }
1363
1364 switch (treeItem->ItemType()) {
1365 case nsIDocShellTreeItem::typeChrome:
1366 return AccessKeyType::eChrome;
1367 case nsIDocShellTreeItem::typeContent:
1368 return AccessKeyType::eContent;
1369 default:
1370 return AccessKeyType::eNone;
1371 }
1372}
1373
1374static bool IsAccessKeyTarget(Element* aElement, nsAString& aKey) {
1375 // Use GetAttr because we want Unicode case=insensitive matching
1376 // XXXbz shouldn't this be case-sensitive, per spec?
1377 nsString contentKey;
1378 if (!aElement || !aElement->GetAttr(nsGkAtoms::accesskey, contentKey) ||
1379 !contentKey.Equals(aKey, nsCaseInsensitiveStringComparator)) {
1380 return false;
1381 }
1382
1383 if (!aElement->IsXULElement()) {
1384 return true;
1385 }
1386
1387 // For XUL we do visibility checks.
1388 nsIFrame* frame = aElement->GetPrimaryFrame();
1389 if (!frame) {
1390 return false;
1391 }
1392
1393 if (frame->IsFocusable()) {
1394 return true;
1395 }
1396
1397 if (!frame->IsVisibleConsideringAncestors()) {
1398 return false;
1399 }
1400
1401 // XUL controls can be activated.
1402 nsCOMPtr<nsIDOMXULControlElement> control = aElement->AsXULControl();
1403 if (control) {
1404 return true;
1405 }
1406
1407 // XUL label elements are never focusable, so we need to check for them
1408 // explicitly before giving up.
1409 if (aElement->IsXULElement(nsGkAtoms::label)) {
1410 return true;
1411 }
1412
1413 return false;
1414}
1415
1416bool EventStateManager::CheckIfEventMatchesAccessKey(
1417 WidgetKeyboardEvent* aEvent, nsPresContext* aPresContext) {
1418 AutoTArray<uint32_t, 10> accessCharCodes;
1419 aEvent->GetAccessKeyCandidates(accessCharCodes);
1420 return WalkESMTreeToHandleAccessKey(aEvent, aPresContext, accessCharCodes,
1421 nullptr, eAccessKeyProcessingNormal,
1422 false);
1423}
1424
1425bool EventStateManager::LookForAccessKeyAndExecute(
1426 nsTArray<uint32_t>& aAccessCharCodes, bool aIsTrustedEvent, bool aIsRepeat,
1427 bool aExecute) {
1428 int32_t count, start = -1;
1429 if (Element* focusedElement = GetFocusedElement()) {
1430 start = mAccessKeys.IndexOf(focusedElement);
1431 if (start == -1 && focusedElement->IsInNativeAnonymousSubtree()) {
1432 start = mAccessKeys.IndexOf(Element::FromNodeOrNull(
1433 focusedElement->GetClosestNativeAnonymousSubtreeRootParentOrHost()));
1434 }
1435 }
1436 RefPtr<Element> element;
1437 int32_t length = mAccessKeys.Count();
1438 for (uint32_t i = 0; i < aAccessCharCodes.Length(); ++i) {
1439 uint32_t ch = aAccessCharCodes[i];
1440 nsAutoString accessKey;
1441 AppendUCS4ToUTF16(ch, accessKey);
1442 for (count = 1; count <= length; ++count) {
1443 // mAccessKeys always stores Element instances.
1444 MOZ_DIAGNOSTIC_ASSERT(length == mAccessKeys.Count())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(length == mAccessKeys.Count())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(length == mAccessKeys.Count(
)))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("length == mAccessKeys.Count()", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1444); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "length == mAccessKeys.Count()"
")"); do { *((volatile int*)__null) = 1444; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1445 element = mAccessKeys[(start + count) % length];
1446 if (IsAccessKeyTarget(element, accessKey)) {
1447 if (!aExecute) {
1448 return true;
1449 }
1450 Document* doc = element->OwnerDoc();
1451 const bool shouldActivate = [&] {
1452 if (!StaticPrefs::accessibility_accesskeycausesactivation()) {
1453 return false;
1454 }
1455 if (aIsRepeat && nsContentUtils::IsChromeDoc(doc)) {
1456 return false;
1457 }
1458
1459 // XXXedgar, Bug 1700646, maybe we could use other data structure to
1460 // make searching target with same accesskey easier, and current setup
1461 // could not ensure we cycle the target with tree order.
1462 int32_t j = 0;
1463 while (++j < length) {
1464 Element* el = mAccessKeys[(start + count + j) % length];
1465 if (IsAccessKeyTarget(el, accessKey)) {
1466 return false;
1467 }
1468 }
1469 return true;
1470 }();
1471
1472 // TODO(bug 1641171): This shouldn't be needed if we considered the
1473 // accesskey combination properly.
1474 if (aIsTrustedEvent) {
1475 doc->NotifyUserGestureActivation();
1476 }
1477
1478 auto result =
1479 element->PerformAccesskey(shouldActivate, aIsTrustedEvent);
1480 if (result.isOk()) {
1481 if (result.unwrap() && aIsTrustedEvent) {
1482 // If this is a child process, inform the parent that we want the
1483 // focus, but pass false since we don't want to change the window
1484 // order.
1485 nsIDocShell* docShell = mPresContext->GetDocShell();
1486 nsCOMPtr<nsIBrowserChild> child =
1487 docShell ? docShell->GetBrowserChild() : nullptr;
1488 if (child) {
1489 child->SendRequestFocus(false, CallerType::System);
1490 }
1491 }
1492 return true;
1493 }
1494 }
1495 }
1496 }
1497 return false;
1498}
1499
1500// static
1501void EventStateManager::GetAccessKeyLabelPrefix(Element* aElement,
1502 nsAString& aPrefix) {
1503 aPrefix.Truncate();
1504 nsAutoString separator, modifierText;
1505 nsContentUtils::GetModifierSeparatorText(separator);
1506
1507 AccessKeyType accessKeyType =
1508 GetAccessKeyTypeFor(aElement->OwnerDoc()->GetDocShell());
1509 if (accessKeyType == AccessKeyType::eNone) {
1510 return;
1511 }
1512 Modifiers modifiers = WidgetKeyboardEvent::AccessKeyModifiers(accessKeyType);
1513 if (modifiers == MODIFIER_NONE) {
1514 return;
1515 }
1516
1517 if (modifiers & MODIFIER_CONTROL) {
1518 nsContentUtils::GetControlText(modifierText);
1519 aPrefix.Append(modifierText + separator);
1520 }
1521 if (modifiers & MODIFIER_META) {
1522 nsContentUtils::GetCommandOrWinText(modifierText);
1523 aPrefix.Append(modifierText + separator);
1524 }
1525 if (modifiers & MODIFIER_ALT) {
1526 nsContentUtils::GetAltText(modifierText);
1527 aPrefix.Append(modifierText + separator);
1528 }
1529 if (modifiers & MODIFIER_SHIFT) {
1530 nsContentUtils::GetShiftText(modifierText);
1531 aPrefix.Append(modifierText + separator);
1532 }
1533}
1534
1535struct MOZ_STACK_CLASS AccessKeyInfo {
1536 WidgetKeyboardEvent* event;
1537 nsTArray<uint32_t>& charCodes;
1538
1539 AccessKeyInfo(WidgetKeyboardEvent* aEvent, nsTArray<uint32_t>& aCharCodes)
1540 : event(aEvent), charCodes(aCharCodes) {}
1541};
1542
1543bool EventStateManager::WalkESMTreeToHandleAccessKey(
1544 WidgetKeyboardEvent* aEvent, nsPresContext* aPresContext,
1545 nsTArray<uint32_t>& aAccessCharCodes, nsIDocShellTreeItem* aBubbledFrom,
1546 ProcessingAccessKeyState aAccessKeyState, bool aExecute) {
1547 EnsureDocument(mPresContext);
1548 nsCOMPtr<nsIDocShell> docShell = aPresContext->GetDocShell();
1549 if (NS_WARN_IF(!docShell)NS_warn_if_impl(!docShell, "!docShell", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1549)
|| NS_WARN_IF(!mDocument)NS_warn_if_impl(!mDocument, "!mDocument", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1549)
) {
1550 return false;
1551 }
1552 AccessKeyType accessKeyType = GetAccessKeyTypeFor(docShell);
1553 if (accessKeyType == AccessKeyType::eNone) {
1554 return false;
1555 }
1556 // Alt or other accesskey modifier is down, we may need to do an accesskey.
1557 if (mAccessKeys.Count() > 0 &&
1558 aEvent->ModifiersMatchWithAccessKey(accessKeyType)) {
1559 // Someone registered an accesskey. Find and activate it.
1560 if (LookForAccessKeyAndExecute(aAccessCharCodes, aEvent->IsTrusted(),
1561 aEvent->mIsRepeat, aExecute)) {
1562 return true;
1563 }
1564 }
1565
1566 int32_t childCount;
1567 docShell->GetInProcessChildCount(&childCount);
1568 for (int32_t counter = 0; counter < childCount; counter++) {
1569 // Not processing the child which bubbles up the handling
1570 nsCOMPtr<nsIDocShellTreeItem> subShellItem;
1571 docShell->GetInProcessChildAt(counter, getter_AddRefs(subShellItem));
1572 if (aAccessKeyState == eAccessKeyProcessingUp &&
1573 subShellItem == aBubbledFrom) {
1574 continue;
1575 }
1576
1577 nsCOMPtr<nsIDocShell> subDS = do_QueryInterface(subShellItem);
1578 if (subDS && IsShellVisible(subDS)) {
1579 // Guarantee subPresShell lifetime while we're handling access key
1580 // since somebody may assume that it won't be deleted before the
1581 // corresponding nsPresContext and EventStateManager.
1582 RefPtr<PresShell> subPresShell = subDS->GetPresShell();
1583
1584 // Docshells need not have a presshell (eg. display:none
1585 // iframes, docshells in transition between documents, etc).
1586 if (!subPresShell) {
1587 // Oh, well. Just move on to the next child
1588 continue;
1589 }
1590
1591 RefPtr<nsPresContext> subPresContext = subPresShell->GetPresContext();
1592
1593 RefPtr<EventStateManager> esm =
1594 static_cast<EventStateManager*>(subPresContext->EventStateManager());
1595
1596 if (esm && esm->WalkESMTreeToHandleAccessKey(
1597 aEvent, subPresContext, aAccessCharCodes, nullptr,
1598 eAccessKeyProcessingDown, aExecute)) {
1599 return true;
1600 }
1601 }
1602 } // if end . checking all sub docshell ends here.
1603
1604 // bubble up the process to the parent docshell if necessary
1605 if (eAccessKeyProcessingDown != aAccessKeyState) {
1606 nsCOMPtr<nsIDocShellTreeItem> parentShellItem;
1607 docShell->GetInProcessParent(getter_AddRefs(parentShellItem));
1608 nsCOMPtr<nsIDocShell> parentDS = do_QueryInterface(parentShellItem);
1609 if (parentDS) {
1610 // Guarantee parentPresShell lifetime while we're handling access key
1611 // since somebody may assume that it won't be deleted before the
1612 // corresponding nsPresContext and EventStateManager.
1613 RefPtr<PresShell> parentPresShell = parentDS->GetPresShell();
1614 NS_ASSERTION(parentPresShell,do { if (!(parentPresShell)) { NS_DebugBreak(NS_DEBUG_ASSERTION
, "Our PresShell exists but the parent's does not?", "parentPresShell"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1615); MOZ_PretendNoReturn(); } } while (0)
1615 "Our PresShell exists but the parent's does not?")do { if (!(parentPresShell)) { NS_DebugBreak(NS_DEBUG_ASSERTION
, "Our PresShell exists but the parent's does not?", "parentPresShell"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1615); MOZ_PretendNoReturn(); } } while (0)
;
1616
1617 RefPtr<nsPresContext> parentPresContext =
1618 parentPresShell->GetPresContext();
1619 NS_ASSERTION(parentPresContext, "PresShell without PresContext")do { if (!(parentPresContext)) { NS_DebugBreak(NS_DEBUG_ASSERTION
, "PresShell without PresContext", "parentPresContext", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1619); MOZ_PretendNoReturn(); } } while (0)
;
1620
1621 RefPtr<EventStateManager> esm = static_cast<EventStateManager*>(
1622 parentPresContext->EventStateManager());
1623 if (esm && esm->WalkESMTreeToHandleAccessKey(
1624 aEvent, parentPresContext, aAccessCharCodes, docShell,
1625 eAccessKeyProcessingDown, aExecute)) {
1626 return true;
1627 }
1628 }
1629 } // if end. bubble up process
1630
1631 // If the content access key modifier is pressed, try remote children
1632 if (aExecute &&
1633 aEvent->ModifiersMatchWithAccessKey(AccessKeyType::eContent) &&
1634 mDocument && mDocument->GetWindow()) {
1635 // If the focus is currently on a node with a BrowserParent, the key event
1636 // should've gotten forwarded to the child process and HandleAccessKey
1637 // called from there.
1638 if (BrowserParent::GetFrom(GetFocusedElement())) {
1639 // If access key may be only in remote contents, this method won't handle
1640 // access key synchronously. In this case, only reply event should reach
1641 // here.
1642 MOZ_ASSERT(aEvent->IsHandledInRemoteProcess() ||do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aEvent->IsHandledInRemoteProcess() || !aEvent->
IsWaitingReplyFromRemoteProcess())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aEvent->IsHandledInRemoteProcess
() || !aEvent->IsWaitingReplyFromRemoteProcess()))), 0))) {
do { } while (false); MOZ_ReportAssertionFailure("aEvent->IsHandledInRemoteProcess() || !aEvent->IsWaitingReplyFromRemoteProcess()"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1643); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aEvent->IsHandledInRemoteProcess() || !aEvent->IsWaitingReplyFromRemoteProcess()"
")"); do { *((volatile int*)__null) = 1643; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
1643 !aEvent->IsWaitingReplyFromRemoteProcess())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aEvent->IsHandledInRemoteProcess() || !aEvent->
IsWaitingReplyFromRemoteProcess())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aEvent->IsHandledInRemoteProcess
() || !aEvent->IsWaitingReplyFromRemoteProcess()))), 0))) {
do { } while (false); MOZ_ReportAssertionFailure("aEvent->IsHandledInRemoteProcess() || !aEvent->IsWaitingReplyFromRemoteProcess()"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1643); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aEvent->IsHandledInRemoteProcess() || !aEvent->IsWaitingReplyFromRemoteProcess()"
")"); do { *((volatile int*)__null) = 1643; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1644 }
1645 // If focus is somewhere else, then we need to check the remote children.
1646 // However, if the event has already been handled in a remote process,
1647 // then, focus is moved from the remote process after posting the event.
1648 // In such case, we shouldn't retry to handle access keys in remote
1649 // processes.
1650 else if (!aEvent->IsHandledInRemoteProcess()) {
1651 AccessKeyInfo accessKeyInfo(aEvent, aAccessCharCodes);
1652 nsContentUtils::CallOnAllRemoteChildren(
1653 mDocument->GetWindow(),
1654 [&accessKeyInfo](BrowserParent* aBrowserParent) -> CallState {
1655 // Only forward accesskeys for the active tab.
1656 if (aBrowserParent->GetDocShellIsActive()) {
1657 // Even if there is no target for the accesskey in this process,
1658 // the event may match with a content accesskey. If so, the
1659 // keyboard event should be handled with reply event for
1660 // preventing double action. (e.g., Alt+Shift+F on Windows may
1661 // focus a content in remote and open "File" menu.)
1662 accessKeyInfo.event->StopPropagation();
1663 accessKeyInfo.event->MarkAsWaitingReplyFromRemoteProcess();
1664 aBrowserParent->HandleAccessKey(*accessKeyInfo.event,
1665 accessKeyInfo.charCodes);
1666 return CallState::Stop;
1667 }
1668
1669 return CallState::Continue;
1670 });
1671 }
1672 }
1673
1674 return false;
1675} // end of HandleAccessKey
1676
1677static BrowserParent* GetBrowserParentAncestor(BrowserParent* aBrowserParent) {
1678 MOZ_ASSERT(aBrowserParent)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aBrowserParent)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aBrowserParent))), 0))) { do
{ } while (false); MOZ_ReportAssertionFailure("aBrowserParent"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1678); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aBrowserParent"
")"); do { *((volatile int*)__null) = 1678; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1679
1680 BrowserBridgeParent* bbp = aBrowserParent->GetBrowserBridgeParent();
1681 if (!bbp) {
1682 return nullptr;
1683 }
1684
1685 return bbp->Manager();
1686}
1687
1688static void DispatchCrossProcessMouseExitEvents(WidgetMouseEvent* aMouseEvent,
1689 BrowserParent* aRemoteTarget,
1690 BrowserParent* aStopAncestor,
1691 bool aIsReallyExit) {
1692 MOZ_ASSERT(aMouseEvent)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aMouseEvent)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aMouseEvent))), 0))) { do { }
while (false); MOZ_ReportAssertionFailure("aMouseEvent", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1692); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aMouseEvent"
")"); do { *((volatile int*)__null) = 1692; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1693 MOZ_ASSERT(aRemoteTarget)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aRemoteTarget)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aRemoteTarget))), 0))) { do {
} while (false); MOZ_ReportAssertionFailure("aRemoteTarget",
"/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1693); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aRemoteTarget"
")"); do { *((volatile int*)__null) = 1693; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1694 MOZ_ASSERT(aRemoteTarget != aStopAncestor)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aRemoteTarget != aStopAncestor)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aRemoteTarget != aStopAncestor
))), 0))) { do { } while (false); MOZ_ReportAssertionFailure(
"aRemoteTarget != aStopAncestor", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1694); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aRemoteTarget != aStopAncestor"
")"); do { *((volatile int*)__null) = 1694; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1695 MOZ_ASSERT_IF(aStopAncestor, nsContentUtils::GetCommonBrowserParentAncestor(do { if (aStopAncestor) { do { static_assert( mozilla::detail
::AssertionConditionType<decltype(nsContentUtils::GetCommonBrowserParentAncestor
( aRemoteTarget, aStopAncestor))>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(nsContentUtils::GetCommonBrowserParentAncestor
( aRemoteTarget, aStopAncestor)))), 0))) { do { } while (false
); MOZ_ReportAssertionFailure("nsContentUtils::GetCommonBrowserParentAncestor( aRemoteTarget, aStopAncestor)"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1696); AnnotateMozCrashReason("MOZ_ASSERT" "(" "nsContentUtils::GetCommonBrowserParentAncestor( aRemoteTarget, aStopAncestor)"
")"); do { *((volatile int*)__null) = 1696; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
1696 aRemoteTarget, aStopAncestor))do { if (aStopAncestor) { do { static_assert( mozilla::detail
::AssertionConditionType<decltype(nsContentUtils::GetCommonBrowserParentAncestor
( aRemoteTarget, aStopAncestor))>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(nsContentUtils::GetCommonBrowserParentAncestor
( aRemoteTarget, aStopAncestor)))), 0))) { do { } while (false
); MOZ_ReportAssertionFailure("nsContentUtils::GetCommonBrowserParentAncestor( aRemoteTarget, aStopAncestor)"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1696); AnnotateMozCrashReason("MOZ_ASSERT" "(" "nsContentUtils::GetCommonBrowserParentAncestor( aRemoteTarget, aStopAncestor)"
")"); do { *((volatile int*)__null) = 1696; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
;
1697
1698 while (aRemoteTarget != aStopAncestor) {
1699 UniquePtr<WidgetMouseEvent> mouseExitEvent =
1700 CreateMouseOrPointerWidgetEvent(aMouseEvent, eMouseExitFromWidget,
1701 aMouseEvent->mRelatedTarget);
1702 mouseExitEvent->mExitFrom =
1703 Some(aIsReallyExit ? WidgetMouseEvent::ePuppet
1704 : WidgetMouseEvent::ePuppetParentToPuppetChild);
1705 aRemoteTarget->SendRealMouseEvent(*mouseExitEvent);
1706
1707 aRemoteTarget = GetBrowserParentAncestor(aRemoteTarget);
1708 }
1709}
1710
1711void EventStateManager::DispatchCrossProcessEvent(WidgetEvent* aEvent,
1712 BrowserParent* aRemoteTarget,
1713 nsEventStatus* aStatus) {
1714 MOZ_ASSERT(aEvent)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aEvent)>::isValid, "invalid assertion condition")
; if ((__builtin_expect(!!(!(!!(aEvent))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("aEvent", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1714); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aEvent" ")"
); do { *((volatile int*)__null) = 1714; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1
Assuming 'aEvent' is non-null
2
Taking false branch
3
Loop condition is false. Exiting loop
1715 MOZ_ASSERT(aRemoteTarget)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aRemoteTarget)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aRemoteTarget))), 0))) { do {
} while (false); MOZ_ReportAssertionFailure("aRemoteTarget",
"/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1715); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aRemoteTarget"
")"); do { *((volatile int*)__null) = 1715; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
4
Assuming 'aRemoteTarget' is non-null
5
Taking false branch
6
Loop condition is false. Exiting loop
1716 MOZ_ASSERT(aStatus)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aStatus)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aStatus))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("aStatus", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1716); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aStatus" ")"
); do { *((volatile int*)__null) = 1716; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
7
Assuming 'aStatus' is non-null
8
Taking false branch
9
Loop condition is false. Exiting loop
1717
1718 BrowserParent* remote = aRemoteTarget;
1719
1720 WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent();
10
'mouseEvent' initialized here
1721 bool isContextMenuKey = mouseEvent && mouseEvent->IsContextMenuKeyEvent();
11
Assuming 'mouseEvent' is null
1722 if (aEvent->mClass == eKeyboardEventClass || isContextMenuKey
12.1
'isContextMenuKey' is false
) {
12
Assuming field 'mClass' is not equal to eKeyboardEventClass
13
Taking false branch
1723 // APZ attaches a LayersId to hit-testable events, for keyboard events,
1724 // we use focus.
1725 BrowserParent* preciseRemote = BrowserParent::GetFocused();
1726 if (preciseRemote) {
1727 remote = preciseRemote;
1728 }
1729 // else there is a race between layout and focus tracking,
1730 // so fall back to delivering the event to the topmost child process.
1731 } else if (aEvent->mLayersId.IsValid()) {
14
Taking false branch
1732 BrowserParent* preciseRemote =
1733 BrowserParent::GetBrowserParentFromLayersId(aEvent->mLayersId);
1734 if (preciseRemote) {
1735 remote = preciseRemote;
1736 }
1737 // else there is a race between APZ and the LayersId to BrowserParent
1738 // mapping, so fall back to delivering the event to the topmost child
1739 // process.
1740 }
1741
1742 switch (aEvent->mClass) {
15
Control jumps to 'case eMouseEventClass:' at line 1743
1743 case eMouseEventClass: {
1744 BrowserParent* oldRemote = BrowserParent::GetLastMouseRemoteTarget();
1745
1746 // If this is a eMouseExitFromWidget event, need to redirect the event to
1747 // the last remote and and notify all its ancestors about the exit, if
1748 // any.
1749 if (mouseEvent->mMessage == eMouseExitFromWidget) {
16
Access to field 'mMessage' results in a dereference of a null pointer (loaded from variable 'mouseEvent')
1750 MOZ_ASSERT(mouseEvent->mExitFrom.value() == WidgetMouseEvent::ePuppet)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mouseEvent->mExitFrom.value() == WidgetMouseEvent
::ePuppet)>::isValid, "invalid assertion condition"); if (
(__builtin_expect(!!(!(!!(mouseEvent->mExitFrom.value() ==
WidgetMouseEvent::ePuppet))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("mouseEvent->mExitFrom.value() == WidgetMouseEvent::ePuppet"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1750); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mouseEvent->mExitFrom.value() == WidgetMouseEvent::ePuppet"
")"); do { *((volatile int*)__null) = 1750; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1751 MOZ_ASSERT(mouseEvent->mReason == WidgetMouseEvent::eReal)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mouseEvent->mReason == WidgetMouseEvent::eReal)>
::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(mouseEvent->mReason == WidgetMouseEvent::eReal)))
, 0))) { do { } while (false); MOZ_ReportAssertionFailure("mouseEvent->mReason == WidgetMouseEvent::eReal"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1751); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mouseEvent->mReason == WidgetMouseEvent::eReal"
")"); do { *((volatile int*)__null) = 1751; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1752 MOZ_ASSERT(!mouseEvent->mLayersId.IsValid())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!mouseEvent->mLayersId.IsValid())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!mouseEvent->mLayersId.IsValid
()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("!mouseEvent->mLayersId.IsValid()", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1752); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!mouseEvent->mLayersId.IsValid()"
")"); do { *((volatile int*)__null) = 1752; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1753 MOZ_ASSERT(remote->GetBrowserHost())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(remote->GetBrowserHost())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(remote->GetBrowserHost())
)), 0))) { do { } while (false); MOZ_ReportAssertionFailure("remote->GetBrowserHost()"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1753); AnnotateMozCrashReason("MOZ_ASSERT" "(" "remote->GetBrowserHost()"
")"); do { *((volatile int*)__null) = 1753; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1754
1755 if (oldRemote && oldRemote != remote) {
1756 Unused << NS_WARN_IF(nsContentUtils::GetCommonBrowserParentAncestor(NS_warn_if_impl(nsContentUtils::GetCommonBrowserParentAncestor
( remote, oldRemote) != remote, "nsContentUtils::GetCommonBrowserParentAncestor( remote, oldRemote) != remote"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1757)
1757 remote, oldRemote) != remote)NS_warn_if_impl(nsContentUtils::GetCommonBrowserParentAncestor
( remote, oldRemote) != remote, "nsContentUtils::GetCommonBrowserParentAncestor( remote, oldRemote) != remote"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1757)
;
1758 remote = oldRemote;
1759 }
1760
1761 DispatchCrossProcessMouseExitEvents(mouseEvent, remote, nullptr, true);
1762 return;
1763 }
1764
1765 if (BrowserParent* pointerLockedRemote =
1766 PointerLockManager::GetLockedRemoteTarget()) {
1767 remote = pointerLockedRemote;
1768 } else if (BrowserParent* pointerCapturedRemote =
1769 PointerEventHandler::GetPointerCapturingRemoteTarget(
1770 mouseEvent->pointerId)) {
1771 remote = pointerCapturedRemote;
1772 } else if (BrowserParent* capturingRemote =
1773 PresShell::GetCapturingRemoteTarget()) {
1774 remote = capturingRemote;
1775 }
1776
1777 // If a mouse is over a remote target A, and then moves to
1778 // remote target B, we'd deliver the event directly to remote target B
1779 // after the moving, A would never get notified that the mouse left.
1780 // So we generate a exit event to notify A after the move.
1781 // XXXedgar, if the synthesized mouse events could deliver to the correct
1782 // process directly (see
1783 // https://bugzilla.mozilla.org/show_bug.cgi?id=1549355), we probably
1784 // don't need to check mReason then.
1785 if (mouseEvent->mReason == WidgetMouseEvent::eReal &&
1786 remote != oldRemote) {
1787 MOZ_ASSERT(mouseEvent->mMessage != eMouseExitFromWidget)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mouseEvent->mMessage != eMouseExitFromWidget)>
::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(mouseEvent->mMessage != eMouseExitFromWidget))), 0
))) { do { } while (false); MOZ_ReportAssertionFailure("mouseEvent->mMessage != eMouseExitFromWidget"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1787); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mouseEvent->mMessage != eMouseExitFromWidget"
")"); do { *((volatile int*)__null) = 1787; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1788 if (oldRemote) {
1789 BrowserParent* commonAncestor =
1790 nsContentUtils::GetCommonBrowserParentAncestor(remote, oldRemote);
1791 if (commonAncestor == oldRemote) {
1792 // Mouse moves to the inner OOP frame, it is not a really exit.
1793 DispatchCrossProcessMouseExitEvents(
1794 mouseEvent, GetBrowserParentAncestor(remote),
1795 GetBrowserParentAncestor(commonAncestor), false);
1796 } else if (commonAncestor == remote) {
1797 // Mouse moves to the outer OOP frame, it is a really exit.
1798 DispatchCrossProcessMouseExitEvents(mouseEvent, oldRemote,
1799 commonAncestor, true);
1800 } else {
1801 // Mouse moves to OOP frame in other subtree, it is a really exit,
1802 // need to notify all its ancestors before common ancestor about the
1803 // exit.
1804 DispatchCrossProcessMouseExitEvents(mouseEvent, oldRemote,
1805 commonAncestor, true);
1806 if (commonAncestor) {
1807 UniquePtr<WidgetMouseEvent> mouseExitEvent =
1808 CreateMouseOrPointerWidgetEvent(mouseEvent,
1809 eMouseExitFromWidget,
1810 mouseEvent->mRelatedTarget);
1811 mouseExitEvent->mExitFrom =
1812 Some(WidgetMouseEvent::ePuppetParentToPuppetChild);
1813 commonAncestor->SendRealMouseEvent(*mouseExitEvent);
1814 }
1815 }
1816 }
1817
1818 if (mouseEvent->mMessage != eMouseExitFromWidget &&
1819 mouseEvent->mMessage != eMouseEnterIntoWidget) {
1820 // This is to make cursor would be updated correctly.
1821 remote->MouseEnterIntoWidget();
1822 }
1823 }
1824
1825 remote->SendRealMouseEvent(*mouseEvent);
1826 return;
1827 }
1828 case eKeyboardEventClass: {
1829 auto* keyboardEvent = aEvent->AsKeyboardEvent();
1830 if (aEvent->mMessage == eKeyUp) {
1831 HandleKeyUpInteraction(keyboardEvent);
1832 }
1833 remote->SendRealKeyEvent(*keyboardEvent);
1834 return;
1835 }
1836 case eWheelEventClass: {
1837 if (BrowserParent* pointerLockedRemote =
1838 PointerLockManager::GetLockedRemoteTarget()) {
1839 remote = pointerLockedRemote;
1840 }
1841 remote->SendMouseWheelEvent(*aEvent->AsWheelEvent());
1842 return;
1843 }
1844 case eTouchEventClass: {
1845 // Let the child process synthesize a mouse event if needed, and
1846 // ensure we don't synthesize one in this process.
1847 *aStatus = nsEventStatus_eConsumeNoDefault;
1848 remote->SendRealTouchEvent(*aEvent->AsTouchEvent());
1849 return;
1850 }
1851 case eDragEventClass: {
1852 RefPtr<BrowserParent> browserParent = remote;
1853 browserParent->Manager()->MaybeInvokeDragSession(browserParent,
1854 aEvent->mMessage);
1855
1856 nsCOMPtr<nsIDragSession> dragSession = nsContentUtils::GetDragSession();
1857 uint32_t dropEffect = nsIDragService::DRAGDROP_ACTION_NONE;
1858 uint32_t action = nsIDragService::DRAGDROP_ACTION_NONE;
1859 nsCOMPtr<nsIPrincipal> principal;
1860 nsCOMPtr<nsIContentSecurityPolicy> csp;
1861
1862 if (dragSession) {
1863 dragSession->DragEventDispatchedToChildProcess();
1864 dragSession->GetDragAction(&action);
1865 dragSession->GetTriggeringPrincipal(getter_AddRefs(principal));
1866 dragSession->GetCsp(getter_AddRefs(csp));
1867 RefPtr<DataTransfer> initialDataTransfer =
1868 dragSession->GetDataTransfer();
1869 if (initialDataTransfer) {
1870 dropEffect = initialDataTransfer->DropEffectInt();
1871 }
1872 }
1873
1874 browserParent->SendRealDragEvent(*aEvent->AsDragEvent(), action,
1875 dropEffect, principal, csp);
1876 return;
1877 }
1878 default: {
1879 MOZ_CRASH("Attempt to send non-whitelisted event?")do { do { } while (false); MOZ_ReportCrash("" "Attempt to send non-whitelisted event?"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1879); AnnotateMozCrashReason("MOZ_CRASH(" "Attempt to send non-whitelisted event?"
")"); do { *((volatile int*)__null) = 1879; __attribute__((nomerge
)) ::abort(); } while (false); } while (false)
;
1880 }
1881 }
1882}
1883
1884bool EventStateManager::IsRemoteTarget(nsIContent* target) {
1885 return BrowserParent::GetFrom(target) || BrowserBridgeChild::GetFrom(target);
1886}
1887
1888bool EventStateManager::IsTopLevelRemoteTarget(nsIContent* target) {
1889 return !!BrowserParent::GetFrom(target);
1890}
1891
1892bool EventStateManager::HandleCrossProcessEvent(WidgetEvent* aEvent,
1893 nsEventStatus* aStatus) {
1894 if (!aEvent->CanBeSentToRemoteProcess()) {
1895 return false;
1896 }
1897
1898 MOZ_ASSERT(!aEvent->HasBeenPostedToRemoteProcess(),do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!aEvent->HasBeenPostedToRemoteProcess())>::isValid
, "invalid assertion condition"); if ((__builtin_expect(!!(!(
!!(!aEvent->HasBeenPostedToRemoteProcess()))), 0))) { do {
} while (false); MOZ_ReportAssertionFailure("!aEvent->HasBeenPostedToRemoteProcess()"
" (" "Why do we need to post same event to remote processes again?"
")", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1899); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!aEvent->HasBeenPostedToRemoteProcess()"
") (" "Why do we need to post same event to remote processes again?"
")"); do { *((volatile int*)__null) = 1899; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
1899 "Why do we need to post same event to remote processes again?")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!aEvent->HasBeenPostedToRemoteProcess())>::isValid
, "invalid assertion condition"); if ((__builtin_expect(!!(!(
!!(!aEvent->HasBeenPostedToRemoteProcess()))), 0))) { do {
} while (false); MOZ_ReportAssertionFailure("!aEvent->HasBeenPostedToRemoteProcess()"
" (" "Why do we need to post same event to remote processes again?"
")", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 1899); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!aEvent->HasBeenPostedToRemoteProcess()"
") (" "Why do we need to post same event to remote processes again?"
")"); do { *((volatile int*)__null) = 1899; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
1900
1901 // Collect the remote event targets we're going to forward this
1902 // event to.
1903 //
1904 // NB: the elements of |remoteTargets| must be unique, for correctness.
1905 AutoTArray<RefPtr<BrowserParent>, 1> remoteTargets;
1906 if (aEvent->mClass != eTouchEventClass || aEvent->mMessage == eTouchStart) {
1907 // If this event only has one target, and it's remote, add it to
1908 // the array.
1909 nsIFrame* frame = aEvent->mMessage == eDragExit
1910 ? sLastDragOverFrame.GetFrame()
1911 : GetEventTarget();
1912 nsIContent* target = frame ? frame->GetContent() : nullptr;
1913 if (BrowserParent* remoteTarget = BrowserParent::GetFrom(target)) {
1914 remoteTargets.AppendElement(remoteTarget);
1915 }
1916 } else {
1917 // This is a touch event with possibly multiple touch points.
1918 // Each touch point may have its own target. So iterate through
1919 // all of them and collect the unique set of targets for event
1920 // forwarding.
1921 //
1922 // This loop is similar to the one used in
1923 // PresShell::DispatchTouchEvent().
1924 const WidgetTouchEvent::TouchArray& touches =
1925 aEvent->AsTouchEvent()->mTouches;
1926 for (uint32_t i = 0; i < touches.Length(); ++i) {
1927 Touch* touch = touches[i];
1928 // NB: the |mChanged| check is an optimization, subprocesses can
1929 // compute this for themselves. If the touch hasn't changed, we
1930 // may be able to avoid forwarding the event entirely (which is
1931 // not free).
1932 if (!touch || !touch->mChanged) {
1933 continue;
1934 }
1935 nsCOMPtr<EventTarget> targetPtr = touch->mTarget;
1936 if (!targetPtr) {
1937 continue;
1938 }
1939 nsCOMPtr<nsIContent> target = do_QueryInterface(targetPtr);
1940 BrowserParent* remoteTarget = BrowserParent::GetFrom(target);
1941 if (remoteTarget && !remoteTargets.Contains(remoteTarget)) {
1942 remoteTargets.AppendElement(remoteTarget);
1943 }
1944 }
1945 }
1946
1947 if (remoteTargets.Length() == 0) {
1948 return false;
1949 }
1950
1951 // Dispatch the event to the remote target.
1952 for (uint32_t i = 0; i < remoteTargets.Length(); ++i) {
1953 DispatchCrossProcessEvent(aEvent, remoteTargets[i], aStatus);
1954 }
1955 return aEvent->HasBeenPostedToRemoteProcess();
1956}
1957
1958//
1959// CreateClickHoldTimer
1960//
1961// Fire off a timer for determining if the user wants click-hold. This timer
1962// is a one-shot that will be cancelled when the user moves enough to fire
1963// a drag.
1964//
1965void EventStateManager::CreateClickHoldTimer(nsPresContext* inPresContext,
1966 nsIFrame* inDownFrame,
1967 WidgetGUIEvent* inMouseDownEvent) {
1968 if (!inMouseDownEvent->IsTrusted() ||
1969 IsTopLevelRemoteTarget(mGestureDownContent) ||
1970 PointerLockManager::IsLocked()) {
1971 return;
1972 }
1973
1974 // just to be anal (er, safe)
1975 if (mClickHoldTimer) {
1976 mClickHoldTimer->Cancel();
1977 mClickHoldTimer = nullptr;
1978 }
1979
1980 // if content clicked on has a popup, don't even start the timer
1981 // since we'll end up conflicting and both will show.
1982 if (mGestureDownContent &&
1983 nsContentUtils::HasNonEmptyAttr(mGestureDownContent, kNameSpaceID_None,
1984 nsGkAtoms::popup)) {
1985 return;
1986 }
1987
1988 int32_t clickHoldDelay = StaticPrefs::ui_click_hold_context_menus_delay();
1989 NS_NewTimerWithFuncCallback(
1990 getter_AddRefs(mClickHoldTimer), sClickHoldCallback, this, clickHoldDelay,
1991 nsITimer::TYPE_ONE_SHOT, "EventStateManager::CreateClickHoldTimer");
1992} // CreateClickHoldTimer
1993
1994//
1995// KillClickHoldTimer
1996//
1997// Stop the timer that would show the context menu dead in its tracks
1998//
1999void EventStateManager::KillClickHoldTimer() {
2000 if (mClickHoldTimer) {
2001 mClickHoldTimer->Cancel();
2002 mClickHoldTimer = nullptr;
2003 }
2004}
2005
2006//
2007// sClickHoldCallback
2008//
2009// This fires after the mouse has been down for a certain length of time.
2010//
2011void EventStateManager::sClickHoldCallback(nsITimer* aTimer, void* aESM) {
2012 RefPtr<EventStateManager> self = static_cast<EventStateManager*>(aESM);
2013 if (self) {
2014 self->FireContextClick();
2015 }
2016
2017 // NOTE: |aTimer| and |self->mAutoHideTimer| are invalid after calling
2018 // ClosePopup();
2019
2020} // sAutoHideCallback
2021
2022//
2023// FireContextClick
2024//
2025// If we're this far, our timer has fired, which means the mouse has been down
2026// for a certain period of time and has not moved enough to generate a
2027// dragGesture. We can be certain the user wants a context-click at this stage,
2028// so generate a dom event and fire it in.
2029//
2030// After the event fires, check if PreventDefault() has been set on the event
2031// which means that someone either ate the event or put up a context menu. This
2032// is our cue to stop tracking the drag gesture. If we always did this,
2033// draggable items w/out a context menu wouldn't be draggable after a certain
2034// length of time, which is _not_ what we want.
2035//
2036void EventStateManager::FireContextClick() {
2037 if (!mGestureDownContent || !mPresContext || PointerLockManager::IsLocked()) {
2038 return;
2039 }
2040
2041#ifdef XP_MACOSX
2042 // Hack to ensure that we don't show a context menu when the user
2043 // let go of the mouse after a long cpu-hogging operation prevented
2044 // us from handling any OS events. See bug 117589.
2045 if (!CGEventSourceButtonState(kCGEventSourceStateCombinedSessionState,
2046 kCGMouseButtonLeft))
2047 return;
2048#endif
2049
2050 nsEventStatus status = nsEventStatus_eIgnore;
2051
2052 // Dispatch to the DOM. We have to fake out the ESM and tell it that the
2053 // current target frame is actually where the mouseDown occurred, otherwise it
2054 // will use the frame the mouse is currently over which may or may not be
2055 // the same. (Note: saari and I have decided that we don't have to reset
2056 // |mCurrentTarget| when we're through because no one else is doing anything
2057 // more with this event and it will get reset on the very next event to the
2058 // correct frame).
2059 mCurrentTarget = mPresContext->GetPrimaryFrameFor(mGestureDownContent);
2060 // make sure the widget sticks around
2061 nsCOMPtr<nsIWidget> targetWidget;
2062 if (mCurrentTarget && (targetWidget = mCurrentTarget->GetNearestWidget())) {
2063 NS_ASSERTION(do { if (!(mPresContext == mCurrentTarget->PresContext()))
{ NS_DebugBreak(NS_DEBUG_ASSERTION, "a prescontext returned a primary frame that didn't belong to it?"
, "mPresContext == mCurrentTarget->PresContext()", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 2065); MOZ_PretendNoReturn(); } } while (0)
2064 mPresContext == mCurrentTarget->PresContext(),do { if (!(mPresContext == mCurrentTarget->PresContext()))
{ NS_DebugBreak(NS_DEBUG_ASSERTION, "a prescontext returned a primary frame that didn't belong to it?"
, "mPresContext == mCurrentTarget->PresContext()", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 2065); MOZ_PretendNoReturn(); } } while (0)
2065 "a prescontext returned a primary frame that didn't belong to it?")do { if (!(mPresContext == mCurrentTarget->PresContext()))
{ NS_DebugBreak(NS_DEBUG_ASSERTION, "a prescontext returned a primary frame that didn't belong to it?"
, "mPresContext == mCurrentTarget->PresContext()", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 2065); MOZ_PretendNoReturn(); } } while (0)
;
2066
2067 // before dispatching, check that we're not on something that
2068 // doesn't get a context menu
2069 bool allowedToDispatch = true;
2070
2071 if (mGestureDownContent->IsAnyOfXULElements(nsGkAtoms::scrollbar,
2072 nsGkAtoms::scrollbarbutton,
2073 nsGkAtoms::button)) {
2074 allowedToDispatch = false;
2075 } else if (mGestureDownContent->IsXULElement(nsGkAtoms::toolbarbutton)) {
2076 // a <toolbarbutton> that has the container attribute set
2077 // will already have its own dropdown.
2078 if (nsContentUtils::HasNonEmptyAttr(
2079 mGestureDownContent, kNameSpaceID_None, nsGkAtoms::container)) {
2080 allowedToDispatch = false;
2081 } else {
2082 // If the toolbar button has an open menu, don't attempt to open
2083 // a second menu
2084 if (mGestureDownContent->IsElement() &&
2085 mGestureDownContent->AsElement()->AttrValueIs(
2086 kNameSpaceID_None, nsGkAtoms::open, nsGkAtoms::_true,
2087 eCaseMatters)) {
2088 allowedToDispatch = false;
2089 }
2090 }
2091 } else if (mGestureDownContent->IsHTMLElement()) {
2092 nsCOMPtr<nsIFormControl> formCtrl(do_QueryInterface(mGestureDownContent));
2093
2094 if (formCtrl) {
2095 allowedToDispatch =
2096 formCtrl->IsTextControl(/*aExcludePassword*/ false) ||
2097 formCtrl->ControlType() == FormControlType::InputFile;
2098 } else if (mGestureDownContent->IsAnyOfHTMLElements(
2099 nsGkAtoms::embed, nsGkAtoms::object, nsGkAtoms::label)) {
2100 allowedToDispatch = false;
2101 }
2102 }
2103
2104 if (allowedToDispatch) {
2105 // init the event while mCurrentTarget is still good
2106 WidgetMouseEvent event(true, eContextMenu, targetWidget,
2107 WidgetMouseEvent::eReal);
2108 event.mClickCount = 1;
2109 FillInEventFromGestureDown(&event);
2110
2111 // stop selection tracking, we're in control now
2112 if (mCurrentTarget) {
2113 RefPtr<nsFrameSelection> frameSel = mCurrentTarget->GetFrameSelection();
2114
2115 if (frameSel && frameSel->GetDragState()) {
2116 // note that this can cause selection changed events to fire if we're
2117 // in a text field, which will null out mCurrentTarget
2118 frameSel->SetDragState(false);
2119 }
2120 }
2121
2122 AutoHandlingUserInputStatePusher userInpStatePusher(true, &event);
2123
2124 // dispatch to DOM
2125 RefPtr<nsIContent> gestureDownContent = mGestureDownContent;
2126 RefPtr<nsPresContext> presContext = mPresContext;
2127 EventDispatcher::Dispatch(gestureDownContent, presContext, &event,
2128 nullptr, &status);
2129
2130 // We don't need to dispatch to frame handling because no frames
2131 // watch eContextMenu except for nsMenuFrame and that's only for
2132 // dismissal. That's just as well since we don't really know
2133 // which frame to send it to.
2134 }
2135 }
2136
2137 // now check if the event has been handled. If so, stop tracking a drag
2138 if (status == nsEventStatus_eConsumeNoDefault) {
2139 StopTrackingDragGesture(true);
2140 }
2141
2142 KillClickHoldTimer();
2143
2144} // FireContextClick
2145
2146//
2147// BeginTrackingDragGesture
2148//
2149// Record that the mouse has gone down and that we should move to TRACKING state
2150// of d&d gesture tracker.
2151//
2152// We also use this to track click-hold context menus. When the mouse goes down,
2153// fire off a short timer. If the timer goes off and we have yet to fire the
2154// drag gesture (ie, the mouse hasn't moved a certain distance), then we can
2155// assume the user wants a click-hold, so fire a context-click event. We only
2156// want to cancel the drag gesture if the context-click event is handled.
2157//
2158void EventStateManager::BeginTrackingDragGesture(nsPresContext* aPresContext,
2159 WidgetMouseEvent* inDownEvent,
2160 nsIFrame* inDownFrame) {
2161 if (!inDownEvent->mWidget) {
2162 return;
2163 }
2164
2165 // Note that |inDownEvent| could be either a mouse down event or a
2166 // synthesized mouse move event.
2167 SetGestureDownPoint(inDownEvent);
2168
2169 if (inDownFrame) {
2170 inDownFrame->GetContentForEvent(inDownEvent,
2171 getter_AddRefs(mGestureDownContent));
2172
2173 mGestureDownFrameOwner = inDownFrame->GetContent();
2174 if (!mGestureDownFrameOwner) {
2175 mGestureDownFrameOwner = mGestureDownContent;
2176 }
2177 }
2178 mGestureModifiers = inDownEvent->mModifiers;
2179 mGestureDownButtons = inDownEvent->mButtons;
2180
2181 if (inDownEvent->mMessage != eMouseTouchDrag &&
2182 StaticPrefs::ui_click_hold_context_menus()) {
2183 // fire off a timer to track click-hold
2184 CreateClickHoldTimer(aPresContext, inDownFrame, inDownEvent);
2185 }
2186}
2187
2188void EventStateManager::SetGestureDownPoint(WidgetGUIEvent* aEvent) {
2189 mGestureDownPoint =
2190 GetEventRefPoint(aEvent) + aEvent->mWidget->WidgetToScreenOffset();
2191}
2192
2193LayoutDeviceIntPoint EventStateManager::GetEventRefPoint(
2194 WidgetEvent* aEvent) const {
2195 auto touchEvent = aEvent->AsTouchEvent();
2196 return (touchEvent && !touchEvent->mTouches.IsEmpty())
2197 ? aEvent->AsTouchEvent()->mTouches[0]->mRefPoint
2198 : aEvent->mRefPoint;
2199}
2200
2201void EventStateManager::BeginTrackingRemoteDragGesture(
2202 nsIContent* aContent, RemoteDragStartData* aDragStartData) {
2203 mGestureDownContent = aContent;
2204 mGestureDownFrameOwner = aContent;
2205 mGestureDownInTextControl =
2206 aContent && aContent->IsInNativeAnonymousSubtree() &&
2207 TextControlElement::FromNodeOrNull(
2208 aContent->GetClosestNativeAnonymousSubtreeRootParentOrHost());
2209 mGestureDownDragStartData = aDragStartData;
2210}
2211
2212//
2213// StopTrackingDragGesture
2214//
2215// Record that the mouse has gone back up so that we should leave the TRACKING
2216// state of d&d gesture tracker and return to the START state.
2217//
2218void EventStateManager::StopTrackingDragGesture(bool aClearInChildProcesses) {
2219 mGestureDownContent = nullptr;
2220 mGestureDownFrameOwner = nullptr;
2221 mGestureDownInTextControl = false;
2222 mGestureDownDragStartData = nullptr;
2223
2224 // If a content process starts a drag but the mouse is released before the
2225 // parent starts the actual drag, the content process will think a drag is
2226 // still happening. Inform any child processes with active drags that the drag
2227 // should be stopped.
2228 if (aClearInChildProcesses) {
2229 nsCOMPtr<nsIDragService> dragService =
2230 do_GetService("@mozilla.org/widget/dragservice;1");
2231 if (dragService) {
2232 nsCOMPtr<nsIDragSession> dragSession;
2233 dragService->GetCurrentSession(getter_AddRefs(dragSession));
2234 if (!dragSession) {
2235 // Only notify if there isn't a drag session active.
2236 dragService->RemoveAllChildProcesses();
2237 }
2238 }
2239 }
2240}
2241
2242void EventStateManager::FillInEventFromGestureDown(WidgetMouseEvent* aEvent) {
2243 NS_ASSERTION(aEvent->mWidget == mCurrentTarget->GetNearestWidget(),do { if (!(aEvent->mWidget == mCurrentTarget->GetNearestWidget
())) { NS_DebugBreak(NS_DEBUG_ASSERTION, "Incorrect widget in event"
, "aEvent->mWidget == mCurrentTarget->GetNearestWidget()"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 2244); MOZ_PretendNoReturn(); } } while (0)
2244 "Incorrect widget in event")do { if (!(aEvent->mWidget == mCurrentTarget->GetNearestWidget
())) { NS_DebugBreak(NS_DEBUG_ASSERTION, "Incorrect widget in event"
, "aEvent->mWidget == mCurrentTarget->GetNearestWidget()"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 2244); MOZ_PretendNoReturn(); } } while (0)
;
2245
2246 // Set the coordinates in the new event to the coordinates of
2247 // the old event, adjusted for the fact that the widget might be
2248 // different
2249 aEvent->mRefPoint =
2250 mGestureDownPoint - aEvent->mWidget->WidgetToScreenOffset();
2251 aEvent->mModifiers = mGestureModifiers;
2252 aEvent->mButtons = mGestureDownButtons;
2253}
2254
2255void EventStateManager::MaybeFirePointerCancel(WidgetInputEvent* aEvent) {
2256 RefPtr<PresShell> presShell = mPresContext->GetPresShell();
2257 AutoWeakFrame targetFrame = mCurrentTarget;
2258
2259 if (!presShell || !targetFrame) {
2260 return;
2261 }
2262
2263 nsCOMPtr<nsIContent> content;
2264 targetFrame->GetContentForEvent(aEvent, getter_AddRefs(content));
2265 if (!content) {
2266 return;
2267 }
2268
2269 nsEventStatus status = nsEventStatus_eIgnore;
2270
2271 if (WidgetMouseEvent* aMouseEvent = aEvent->AsMouseEvent()) {
2272 WidgetPointerEvent event(*aMouseEvent);
2273 PointerEventHandler::InitPointerEventFromMouse(&event, aMouseEvent,
2274 ePointerCancel);
2275
2276 event.convertToPointer = false;
2277 presShell->HandleEventWithTarget(&event, targetFrame, content, &status);
2278 } else if (WidgetTouchEvent* aTouchEvent = aEvent->AsTouchEvent()) {
2279 WidgetPointerEvent event(aTouchEvent->IsTrusted(), ePointerCancel,
2280 aTouchEvent->mWidget);
2281
2282 PointerEventHandler::InitPointerEventFromTouch(event, *aTouchEvent,
2283 *aTouchEvent->mTouches[0]);
2284
2285 event.convertToPointer = false;
2286 presShell->HandleEventWithTarget(&event, targetFrame, content, &status);
2287 } else {
2288 MOZ_ASSERT(false)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(false)>::isValid, "invalid assertion condition");
if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("false", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 2288); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ")")
; do { *((volatile int*)__null) = 2288; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
2289 }
2290
2291 // HandleEventWithTarget clears out mCurrentTarget, which may be used in the
2292 // caller GenerateDragGesture. We have to restore mCurrentTarget.
2293 mCurrentTarget = targetFrame;
2294}
2295
2296bool EventStateManager::IsEventOutsideDragThreshold(
2297 WidgetInputEvent* aEvent) const {
2298 static int32_t sPixelThresholdX = 0;
2299 static int32_t sPixelThresholdY = 0;
2300
2301 if (!sPixelThresholdX) {
2302 sPixelThresholdX =
2303 LookAndFeel::GetInt(LookAndFeel::IntID::DragThresholdX, 0);
2304 sPixelThresholdY =
2305 LookAndFeel::GetInt(LookAndFeel::IntID::DragThresholdY, 0);
2306 if (sPixelThresholdX <= 0) {
2307 sPixelThresholdX = 5;
2308 }
2309 if (sPixelThresholdY <= 0) {
2310 sPixelThresholdY = 5;
2311 }
2312 }
2313
2314 LayoutDeviceIntPoint pt =
2315 aEvent->mWidget->WidgetToScreenOffset() + GetEventRefPoint(aEvent);
2316 LayoutDeviceIntPoint distance = pt - mGestureDownPoint;
2317 return Abs(distance.x) > sPixelThresholdX ||
2318 Abs(distance.y) > sPixelThresholdY;
2319}
2320
2321//
2322// GenerateDragGesture
2323//
2324// If we're in the TRACKING state of the d&d gesture tracker, check the current
2325// position of the mouse in relation to the old one. If we've moved a sufficient
2326// amount from the mouse down, then fire off a drag gesture event.
2327void EventStateManager::GenerateDragGesture(nsPresContext* aPresContext,
2328 WidgetInputEvent* aEvent) {
2329 NS_ASSERTION(aPresContext, "This shouldn't happen.")do { if (!(aPresContext)) { NS_DebugBreak(NS_DEBUG_ASSERTION,
"This shouldn't happen.", "aPresContext", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 2329); MOZ_PretendNoReturn(); } } while (0)
;
2330 if (!IsTrackingDragGesture()) {
2331 return;
2332 }
2333
2334 AutoWeakFrame targetFrameBefore = mCurrentTarget;
2335 auto autoRestore = MakeScopeExit([&] { mCurrentTarget = targetFrameBefore; });
2336 mCurrentTarget = mGestureDownFrameOwner->GetPrimaryFrame();
2337
2338 if (!mCurrentTarget || !mCurrentTarget->GetNearestWidget()) {
2339 StopTrackingDragGesture(true);
2340 return;
2341 }
2342
2343 // Check if selection is tracking drag gestures, if so
2344 // don't interfere!
2345 if (mCurrentTarget) {
2346 RefPtr<nsFrameSelection> frameSel = mCurrentTarget->GetFrameSelection();
2347 if (frameSel && frameSel->GetDragState()) {
2348 StopTrackingDragGesture(true);
2349 return;
2350 }
2351 }
2352
2353 // If non-native code is capturing the mouse don't start a drag.
2354 if (PresShell::IsMouseCapturePreventingDrag()) {
2355 StopTrackingDragGesture(true);
2356 return;
2357 }
2358
2359 if (!IsEventOutsideDragThreshold(aEvent)) {
2360 // To keep the old behavior, flush layout even if we don't start dnd.
2361 FlushLayout(aPresContext);
2362 return;
2363 }
2364
2365 if (StaticPrefs::ui_click_hold_context_menus()) {
2366 // stop the click-hold before we fire off the drag gesture, in case
2367 // it takes a long time
2368 KillClickHoldTimer();
2369 }
2370
2371 nsCOMPtr<nsIDocShell> docshell = aPresContext->GetDocShell();
2372 if (!docshell) {
2373 return;
2374 }
2375
2376 nsCOMPtr<nsPIDOMWindowOuter> window = docshell->GetWindow();
2377 if (!window) return;
2378
2379 RefPtr<DataTransfer> dataTransfer =
2380 new DataTransfer(window, eDragStart, false, -1);
2381 auto protectDataTransfer = MakeScopeExit([&] {
2382 if (dataTransfer) {
2383 dataTransfer->Disconnect();
2384 }
2385 });
2386
2387 RefPtr<Selection> selection;
2388 RefPtr<RemoteDragStartData> remoteDragStartData;
2389 nsCOMPtr<nsIContent> eventContent, targetContent;
2390 nsCOMPtr<nsIPrincipal> principal;
2391 nsCOMPtr<nsIContentSecurityPolicy> csp;
2392 nsCOMPtr<nsICookieJarSettings> cookieJarSettings;
2393 bool allowEmptyDataTransfer = false;
2394 mCurrentTarget->GetContentForEvent(aEvent, getter_AddRefs(eventContent));
2395 if (eventContent) {
2396 // If the content is a text node in a password field, we shouldn't
2397 // allow to drag its raw text. Note that we've supported drag from
2398 // password fields but dragging data was masked text. So, it doesn't
2399 // make sense anyway.
2400 if (eventContent->IsText() && eventContent->HasFlag(NS_MAYBE_MASKED)) {
2401 // However, it makes sense to allow to drag selected password text
2402 // when copying selected password is allowed because users may want
2403 // to use drag and drop rather than copy and paste when web apps
2404 // request to input password twice for conforming new password but
2405 // they used password generator.
2406 TextEditor* textEditor =
2407 nsContentUtils::GetTextEditorFromAnonymousNodeWithoutCreation(
2408 eventContent);
2409 if (!textEditor || !textEditor->IsCopyToClipboardAllowed()) {
2410 StopTrackingDragGesture(true);
2411 return;
2412 }
2413 }
2414 DetermineDragTargetAndDefaultData(
2415 window, eventContent, dataTransfer, &allowEmptyDataTransfer,
2416 getter_AddRefs(selection), getter_AddRefs(remoteDragStartData),
2417 getter_AddRefs(targetContent), getter_AddRefs(principal),
2418 getter_AddRefs(csp), getter_AddRefs(cookieJarSettings));
2419 }
2420
2421 // Stop tracking the drag gesture now. This should stop us from
2422 // reentering GenerateDragGesture inside DOM event processing.
2423 // Pass false to avoid clearing the child process state since a real
2424 // drag should be starting.
2425 StopTrackingDragGesture(false);
2426
2427 if (!targetContent) return;
2428
2429 // Use our targetContent, now that we've determined it, as the
2430 // parent object of the DataTransfer.
2431 nsCOMPtr<nsIContent> parentContent =
2432 targetContent->FindFirstNonChromeOnlyAccessContent();
2433 dataTransfer->SetParentObject(parentContent);
2434
2435 sLastDragOverFrame = nullptr;
2436 nsCOMPtr<nsIWidget> widget = mCurrentTarget->GetNearestWidget();
2437
2438 // get the widget from the target frame
2439 WidgetDragEvent startEvent(aEvent->IsTrusted(), eDragStart, widget);
2440 startEvent.mFlags.mIsSynthesizedForTests =
2441 aEvent->mFlags.mIsSynthesizedForTests;
2442 FillInEventFromGestureDown(&startEvent);
2443
2444 startEvent.mDataTransfer = dataTransfer;
2445 if (aEvent->AsMouseEvent()) {
2446 startEvent.mInputSource = aEvent->AsMouseEvent()->mInputSource;
2447 } else if (aEvent->AsTouchEvent()) {
2448 startEvent.mInputSource = MouseEvent_Binding::MOZ_SOURCE_TOUCH;
2449 } else {
2450 MOZ_ASSERT(false)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(false)>::isValid, "invalid assertion condition");
if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("false", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 2450); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ")")
; do { *((volatile int*)__null) = 2450; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
2451 }
2452
2453 // Dispatch to the DOM. By setting mCurrentTarget we are faking
2454 // out the ESM and telling it that the current target frame is
2455 // actually where the mouseDown occurred, otherwise it will use
2456 // the frame the mouse is currently over which may or may not be
2457 // the same.
2458
2459 // Hold onto old target content through the event and reset after.
2460 nsCOMPtr<nsIContent> targetBeforeEvent = mCurrentTargetContent;
2461
2462 // Set the current target to the content for the mouse down
2463 mCurrentTargetContent = targetContent;
2464
2465 // Dispatch the dragstart event to the DOM.
2466 nsEventStatus status = nsEventStatus_eIgnore;
2467 EventDispatcher::Dispatch(targetContent, aPresContext, &startEvent, nullptr,
2468 &status);
2469
2470 WidgetDragEvent* event = &startEvent;
2471
2472 nsCOMPtr<nsIObserverService> observerService =
2473 mozilla::services::GetObserverService();
2474 // Emit observer event to allow addons to modify the DataTransfer
2475 // object.
2476 if (observerService) {
2477 observerService->NotifyObservers(dataTransfer, "on-datatransfer-available",
2478 nullptr);
2479 }
2480
2481 if (status != nsEventStatus_eConsumeNoDefault) {
2482 bool dragStarted = DoDefaultDragStart(aPresContext, event, dataTransfer,
2483 allowEmptyDataTransfer, targetContent,
2484 selection, remoteDragStartData,
2485 principal, csp, cookieJarSettings);
2486 if (dragStarted) {
2487 sActiveESM = nullptr;
2488 MaybeFirePointerCancel(aEvent);
2489 aEvent->StopPropagation();
2490 }
2491 }
2492
2493 // Reset mCurretTargetContent to what it was
2494 mCurrentTargetContent = targetBeforeEvent;
2495
2496 // Now flush all pending notifications, for better responsiveness
2497 // while dragging.
2498 FlushLayout(aPresContext);
2499} // GenerateDragGesture
2500
2501void EventStateManager::DetermineDragTargetAndDefaultData(
2502 nsPIDOMWindowOuter* aWindow, nsIContent* aSelectionTarget,
2503 DataTransfer* aDataTransfer, bool* aAllowEmptyDataTransfer,
2504 Selection** aSelection, RemoteDragStartData** aRemoteDragStartData,
2505 nsIContent** aTargetNode, nsIPrincipal** aPrincipal,
2506 nsIContentSecurityPolicy** aCsp,
2507 nsICookieJarSettings** aCookieJarSettings) {
2508 *aTargetNode = nullptr;
2509 *aAllowEmptyDataTransfer = false;
2510 nsCOMPtr<nsIContent> dragDataNode;
2511
2512 nsIContent* editingElement = aSelectionTarget->IsEditable()
2513 ? aSelectionTarget->GetEditingHost()
2514 : nullptr;
2515
2516 // In chrome, only allow dragging inside editable areas.
2517 bool isChromeContext = !aWindow->GetBrowsingContext()->IsContent();
2518 if (isChromeContext && !editingElement) {
2519 if (mGestureDownDragStartData) {
2520 // A child process started a drag so use any data it assigned for the dnd
2521 // session.
2522 mGestureDownDragStartData->AddInitialDnDDataTo(aDataTransfer, aPrincipal,
2523 aCsp, aCookieJarSettings);
2524 mGestureDownDragStartData.forget(aRemoteDragStartData);
2525 *aAllowEmptyDataTransfer = true;
2526 }
2527 } else {
2528 mGestureDownDragStartData = nullptr;
2529
2530 // GetDragData determines if a selection, link or image in the content
2531 // should be dragged, and places the data associated with the drag in the
2532 // data transfer.
2533 // mGestureDownContent is the node where the mousedown event for the drag
2534 // occurred, and aSelectionTarget is the node to use when a selection is
2535 // used
2536 bool canDrag;
2537 bool wasAlt = (mGestureModifiers & MODIFIER_ALT) != 0;
2538 nsresult rv = nsContentAreaDragDrop::GetDragData(
2539 aWindow, mGestureDownContent, aSelectionTarget, wasAlt, aDataTransfer,
2540 &canDrag, aSelection, getter_AddRefs(dragDataNode), aCsp,
2541 aCookieJarSettings);
2542 if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0))) || !canDrag) {
2543 return;
2544 }
2545 }
2546
2547 // if GetDragData returned a node, use that as the node being dragged.
2548 // Otherwise, if a selection is being dragged, use the node within the
2549 // selection that was dragged. Otherwise, just use the mousedown target.
2550 nsIContent* dragContent = mGestureDownContent;
2551 if (dragDataNode)
2552 dragContent = dragDataNode;
2553 else if (*aSelection)
2554 dragContent = aSelectionTarget;
2555
2556 nsIContent* originalDragContent = dragContent;
2557
2558 // If a selection isn't being dragged, look for an ancestor with the
2559 // draggable property set. If one is found, use that as the target of the
2560 // drag instead of the node that was clicked on. If a draggable node wasn't
2561 // found, just use the clicked node.
2562 if (!*aSelection) {
2563 while (dragContent) {
2564 if (auto htmlElement = nsGenericHTMLElement::FromNode(dragContent)) {
2565 if (htmlElement->Draggable()) {
2566 // We let draggable elements to trigger dnd even if there is no data
2567 // in the DataTransfer.
2568 *aAllowEmptyDataTransfer = true;
2569 break;
2570 }
2571 } else {
2572 if (dragContent->IsXULElement()) {
2573 // All XUL elements are draggable, so if a XUL element is
2574 // encountered, stop looking for draggable nodes and just use the
2575 // original clicked node instead.
2576 // XXXndeakin
2577 // In the future, we will want to improve this so that XUL has a
2578 // better way to specify whether something is draggable than just
2579 // on/off.
2580 dragContent = mGestureDownContent;
2581 break;
2582 }
2583 // otherwise, it's not an HTML or XUL element, so just keep looking
2584 }
2585 dragContent = dragContent->GetFlattenedTreeParent();
2586 }
2587 }
2588
2589 // if no node in the hierarchy was found to drag, but the GetDragData method
2590 // returned a node, use that returned node. Otherwise, nothing is draggable.
2591 if (!dragContent && dragDataNode) dragContent = dragDataNode;
2592
2593 if (dragContent) {
2594 // if an ancestor node was used instead, clear the drag data
2595 // XXXndeakin rework this a bit. Find a way to just not call GetDragData if
2596 // we don't need to.
2597 if (dragContent != originalDragContent) aDataTransfer->ClearAll();
2598 *aTargetNode = dragContent;
2599 NS_ADDREF(*aTargetNode)(*aTargetNode)->AddRef();
2600 }
2601}
2602
2603bool EventStateManager::DoDefaultDragStart(
2604 nsPresContext* aPresContext, WidgetDragEvent* aDragEvent,
2605 DataTransfer* aDataTransfer, bool aAllowEmptyDataTransfer,
2606 nsIContent* aDragTarget, Selection* aSelection,
2607 RemoteDragStartData* aDragStartData, nsIPrincipal* aPrincipal,
2608 nsIContentSecurityPolicy* aCsp, nsICookieJarSettings* aCookieJarSettings) {
2609 nsCOMPtr<nsIDragService> dragService =
2610 do_GetService("@mozilla.org/widget/dragservice;1");
2611 if (!dragService) return false;
2612
2613 // Default handling for the dragstart event.
2614 //
2615 // First, check if a drag session already exists. This means that the drag
2616 // service was called directly within a draggesture handler. In this case,
2617 // don't do anything more, as it is assumed that the handler is managing
2618 // drag and drop manually. Make sure to return true to indicate that a drag
2619 // began. However, if we're handling drag session for synthesized events,
2620 // we need to initialize some information of the session. Therefore, we
2621 // need to keep going for synthesized case.
2622 nsCOMPtr<nsIDragSession> dragSession;
2623 dragService->GetCurrentSession(getter_AddRefs(dragSession));
2624 if (dragSession && !dragSession->IsSynthesizedForTests()) {
2625 return true;
2626 }
2627
2628 // No drag session is currently active, so check if a handler added
2629 // any items to be dragged. If not, there isn't anything to drag.
2630 uint32_t count = 0;
2631 if (aDataTransfer) {
2632 count = aDataTransfer->MozItemCount();
2633 }
2634 if (!aAllowEmptyDataTransfer && !count) {
2635 return false;
2636 }
2637
2638 // Get the target being dragged, which may not be the same as the
2639 // target of the mouse event. If one wasn't set in the
2640 // aDataTransfer during the event handler, just use the original
2641 // target instead.
2642 nsCOMPtr<nsIContent> dragTarget = aDataTransfer->GetDragTarget();
2643 if (!dragTarget) {
2644 dragTarget = aDragTarget;
2645 if (!dragTarget) {
2646 return false;
2647 }
2648 }
2649
2650 // check which drag effect should initially be used. If the effect was not
2651 // set, just use all actions, otherwise Windows won't allow a drop.
2652 uint32_t action = aDataTransfer->EffectAllowedInt();
2653 if (action == nsIDragService::DRAGDROP_ACTION_UNINITIALIZED) {
2654 action = nsIDragService::DRAGDROP_ACTION_COPY |
2655 nsIDragService::DRAGDROP_ACTION_MOVE |
2656 nsIDragService::DRAGDROP_ACTION_LINK;
2657 }
2658
2659 // get any custom drag image that was set
2660 int32_t imageX, imageY;
2661 RefPtr<Element> dragImage = aDataTransfer->GetDragImage(&imageX, &imageY);
2662
2663 nsCOMPtr<nsIArray> transArray = aDataTransfer->GetTransferables(dragTarget);
2664 if (!transArray) {
2665 return false;
2666 }
2667
2668 RefPtr<DataTransfer> dataTransfer;
2669 if (!dragSession) {
2670 // After this function returns, the DataTransfer will be cleared so it
2671 // appears empty to content. We need to pass a DataTransfer into the Drag
2672 // Session, so we need to make a copy.
2673 aDataTransfer->Clone(aDragTarget, eDrop, aDataTransfer->MozUserCancelled(),
2674 false, getter_AddRefs(dataTransfer));
2675
2676 // Copy over the drop effect, as Clone doesn't copy it for us.
2677 dataTransfer->SetDropEffectInt(aDataTransfer->DropEffectInt());
2678 } else {
2679 MOZ_ASSERT(dragSession->IsSynthesizedForTests())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(dragSession->IsSynthesizedForTests())>::isValid
, "invalid assertion condition"); if ((__builtin_expect(!!(!(
!!(dragSession->IsSynthesizedForTests()))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("dragSession->IsSynthesizedForTests()"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 2679); AnnotateMozCrashReason("MOZ_ASSERT" "(" "dragSession->IsSynthesizedForTests()"
")"); do { *((volatile int*)__null) = 2679; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
2680 MOZ_ASSERT(aDragEvent->mFlags.mIsSynthesizedForTests)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aDragEvent->mFlags.mIsSynthesizedForTests)>::isValid
, "invalid assertion condition"); if ((__builtin_expect(!!(!(
!!(aDragEvent->mFlags.mIsSynthesizedForTests))), 0))) { do
{ } while (false); MOZ_ReportAssertionFailure("aDragEvent->mFlags.mIsSynthesizedForTests"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 2680); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aDragEvent->mFlags.mIsSynthesizedForTests"
")"); do { *((volatile int*)__null) = 2680; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
2681 // If we're initializing synthesized drag session, we should use given
2682 // DataTransfer as is because it'll be used with following drag events
2683 // in any tests, therefore it should be set to nsIDragSession.dataTransfer
2684 // because it and DragEvent.dataTransfer should be same instance.
2685 dataTransfer = aDataTransfer;
2686 }
2687
2688 // XXXndeakin don't really want to create a new drag DOM event
2689 // here, but we need something to pass to the InvokeDragSession
2690 // methods.
2691 RefPtr<DragEvent> event =
2692 NS_NewDOMDragEvent(dragTarget, aPresContext, aDragEvent);
2693
2694 // Use InvokeDragSessionWithSelection if a selection is being dragged,
2695 // such that the image can be generated from the selected text. However,
2696 // use InvokeDragSessionWithImage if a custom image was set or something
2697 // other than a selection is being dragged.
2698 if (!dragImage && aSelection) {
2699 dragService->InvokeDragSessionWithSelection(aSelection, aPrincipal, aCsp,
2700 aCookieJarSettings, transArray,
2701 action, event, dataTransfer);
2702 } else if (aDragStartData) {
2703 MOZ_ASSERT(XRE_IsParentProcess())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(XRE_IsParentProcess())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(XRE_IsParentProcess()))), 0)
)) { do { } while (false); MOZ_ReportAssertionFailure("XRE_IsParentProcess()"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 2703); AnnotateMozCrashReason("MOZ_ASSERT" "(" "XRE_IsParentProcess()"
")"); do { *((volatile int*)__null) = 2703; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
2704 dragService->InvokeDragSessionWithRemoteImage(
2705 dragTarget, aPrincipal, aCsp, aCookieJarSettings, transArray, action,
2706 aDragStartData, event, dataTransfer);
2707 } else {
2708 dragService->InvokeDragSessionWithImage(
2709 dragTarget, aPrincipal, aCsp, aCookieJarSettings, transArray, action,
2710 dragImage, imageX, imageY, event, dataTransfer);
2711 }
2712
2713 return true;
2714}
2715
2716void EventStateManager::ChangeZoom(bool aIncrease) {
2717 // Send the zoom change to the top level browser so it will be handled by the
2718 // front end in the same way as other zoom actions.
2719 nsIDocShell* docShell = mDocument->GetDocShell();
2720 if (!docShell) {
2721 return;
2722 }
2723
2724 BrowsingContext* bc = docShell->GetBrowsingContext();
2725 if (!bc) {
2726 return;
2727 }
2728
2729 if (XRE_IsParentProcess()) {
2730 bc->Canonical()->DispatchWheelZoomChange(aIncrease);
2731 } else if (BrowserChild* child = BrowserChild::GetFrom(docShell)) {
2732 child->SendWheelZoomChange(aIncrease);
2733 }
2734}
2735
2736void EventStateManager::DoScrollHistory(int32_t direction) {
2737 nsCOMPtr<nsISupports> pcContainer(mPresContext->GetContainerWeak());
2738 if (pcContainer) {
2739 nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(pcContainer));
2740 if (webNav) {
2741 // positive direction to go back one step, nonpositive to go forward
2742 // This is doing user-initiated history traversal, hence we want
2743 // to require that history entries we navigate to have user interaction.
2744 if (direction > 0)
2745 webNav->GoBack(StaticPrefs::browser_navigation_requireUserInteraction(),
2746 true);
2747 else
2748 webNav->GoForward(
2749 StaticPrefs::browser_navigation_requireUserInteraction(), true);
2750 }
2751 }
2752}
2753
2754void EventStateManager::DoScrollZoom(nsIFrame* aTargetFrame,
2755 int32_t adjustment) {
2756 // Exclude content in chrome docshells.
2757 nsIContent* content = aTargetFrame->GetContent();
2758 if (content && !nsContentUtils::IsInChromeDocshell(content->OwnerDoc())) {
2759 // Positive adjustment to decrease zoom, negative to increase
2760 const bool increase = adjustment <= 0;
2761 EnsureDocument(mPresContext);
2762 ChangeZoom(increase);
2763 }
2764}
2765
2766static nsIFrame* GetParentFrameToScroll(nsIFrame* aFrame) {
2767 if (!aFrame) return nullptr;
2768
2769 if (aFrame->StyleDisplay()->mPosition == StylePositionProperty::Fixed &&
2770 nsLayoutUtils::IsReallyFixedPos(aFrame))
2771 return aFrame->PresShell()->GetRootScrollFrame();
2772
2773 return aFrame->GetParent();
2774}
2775
2776void EventStateManager::DispatchLegacyMouseScrollEvents(
2777 nsIFrame* aTargetFrame, WidgetWheelEvent* aEvent, nsEventStatus* aStatus) {
2778 MOZ_ASSERT(aEvent)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aEvent)>::isValid, "invalid assertion condition")
; if ((__builtin_expect(!!(!(!!(aEvent))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("aEvent", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 2778); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aEvent" ")"
); do { *((volatile int*)__null) = 2778; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
2779 MOZ_ASSERT(aStatus)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aStatus)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aStatus))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("aStatus", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 2779); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aStatus" ")"
); do { *((volatile int*)__null) = 2779; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
2780
2781 if (!aTargetFrame || *aStatus == nsEventStatus_eConsumeNoDefault) {
2782 return;
2783 }
2784
2785 // Ignore mouse wheel transaction for computing legacy mouse wheel
2786 // events' delta value.
2787 // DOM event's delta vales are computed from CSS pixels.
2788 auto scrollAmountInCSSPixels =
2789 CSSIntSize::FromAppUnitsRounded(aEvent->mScrollAmount);
2790
2791 // XXX We don't deal with fractional amount in legacy event, though the
2792 // default action handler (DoScrollText()) deals with it.
2793 // If we implemented such strict computation, we would need additional
2794 // accumulated delta values. It would made the code more complicated.
2795 // And also it would computes different delta values from older version.
2796 // It doesn't make sense to implement such code for legacy events and
2797 // rare cases.
2798 int32_t scrollDeltaX, scrollDeltaY, pixelDeltaX, pixelDeltaY;
2799 switch (aEvent->mDeltaMode) {
2800 case WheelEvent_Binding::DOM_DELTA_PAGE:
2801 scrollDeltaX = !aEvent->mLineOrPageDeltaX
2802 ? 0
2803 : (aEvent->mLineOrPageDeltaX > 0
2804 ? UIEvent_Binding::SCROLL_PAGE_DOWN
2805 : UIEvent_Binding::SCROLL_PAGE_UP);
2806 scrollDeltaY = !aEvent->mLineOrPageDeltaY
2807 ? 0
2808 : (aEvent->mLineOrPageDeltaY > 0
2809 ? UIEvent_Binding::SCROLL_PAGE_DOWN
2810 : UIEvent_Binding::SCROLL_PAGE_UP);
2811 pixelDeltaX = RoundDown(aEvent->mDeltaX * scrollAmountInCSSPixels.width);
2812 pixelDeltaY = RoundDown(aEvent->mDeltaY * scrollAmountInCSSPixels.height);
2813 break;
2814
2815 case WheelEvent_Binding::DOM_DELTA_LINE:
2816 scrollDeltaX = aEvent->mLineOrPageDeltaX;
2817 scrollDeltaY = aEvent->mLineOrPageDeltaY;
2818 pixelDeltaX = RoundDown(aEvent->mDeltaX * scrollAmountInCSSPixels.width);
2819 pixelDeltaY = RoundDown(aEvent->mDeltaY * scrollAmountInCSSPixels.height);
2820 break;
2821
2822 case WheelEvent_Binding::DOM_DELTA_PIXEL:
2823 scrollDeltaX = aEvent->mLineOrPageDeltaX;
2824 scrollDeltaY = aEvent->mLineOrPageDeltaY;
2825 pixelDeltaX = RoundDown(aEvent->mDeltaX);
2826 pixelDeltaY = RoundDown(aEvent->mDeltaY);
2827 break;
2828
2829 default:
2830 MOZ_CRASH("Invalid deltaMode value comes")do { do { } while (false); MOZ_ReportCrash("" "Invalid deltaMode value comes"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 2830); AnnotateMozCrashReason("MOZ_CRASH(" "Invalid deltaMode value comes"
")"); do { *((volatile int*)__null) = 2830; __attribute__((nomerge
)) ::abort(); } while (false); } while (false)
;
2831 }
2832
2833 // Send the legacy events in following order:
2834 // 1. Vertical scroll
2835 // 2. Vertical pixel scroll (even if #1 isn't consumed)
2836 // 3. Horizontal scroll (even if #1 and/or #2 are consumed)
2837 // 4. Horizontal pixel scroll (even if #3 isn't consumed)
2838
2839 AutoWeakFrame targetFrame(aTargetFrame);
2840
2841 MOZ_ASSERT(*aStatus != nsEventStatus_eConsumeNoDefault &&do { static_assert( mozilla::detail::AssertionConditionType<
decltype(*aStatus != nsEventStatus_eConsumeNoDefault &&
!aEvent->DefaultPrevented())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(*aStatus != nsEventStatus_eConsumeNoDefault
&& !aEvent->DefaultPrevented()))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("*aStatus != nsEventStatus_eConsumeNoDefault && !aEvent->DefaultPrevented()"
" (" "If you make legacy events dispatched for default prevented wheel "
"event, you need to initialize stateX and stateY" ")", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 2844); AnnotateMozCrashReason("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" ")"); do {
*((volatile int*)__null) = 2844; __attribute__((nomerge)) ::
abort(); } while (false); } } while (false)
2842 !aEvent->DefaultPrevented(),do { static_assert( mozilla::detail::AssertionConditionType<
decltype(*aStatus != nsEventStatus_eConsumeNoDefault &&
!aEvent->DefaultPrevented())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(*aStatus != nsEventStatus_eConsumeNoDefault
&& !aEvent->DefaultPrevented()))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("*aStatus != nsEventStatus_eConsumeNoDefault && !aEvent->DefaultPrevented()"
" (" "If you make legacy events dispatched for default prevented wheel "
"event, you need to initialize stateX and stateY" ")", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 2844); AnnotateMozCrashReason("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" ")"); do {
*((volatile int*)__null) = 2844; __attribute__((nomerge)) ::
abort(); } while (false); } } while (false)
2843 "If you make legacy events dispatched for default prevented wheel "do { static_assert( mozilla::detail::AssertionConditionType<
decltype(*aStatus != nsEventStatus_eConsumeNoDefault &&
!aEvent->DefaultPrevented())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(*aStatus != nsEventStatus_eConsumeNoDefault
&& !aEvent->DefaultPrevented()))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("*aStatus != nsEventStatus_eConsumeNoDefault && !aEvent->DefaultPrevented()"
" (" "If you make legacy events dispatched for default prevented wheel "
"event, you need to initialize stateX and stateY" ")", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 2844); AnnotateMozCrashReason("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" ")"); do {
*((volatile int*)__null) = 2844; __attribute__((nomerge)) ::
abort(); } while (false); } } while (false)
2844 "event, you need to initialize stateX and stateY")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(*aStatus != nsEventStatus_eConsumeNoDefault &&
!aEvent->DefaultPrevented())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(*aStatus != nsEventStatus_eConsumeNoDefault
&& !aEvent->DefaultPrevented()))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("*aStatus != nsEventStatus_eConsumeNoDefault && !aEvent->DefaultPrevented()"
" (" "If you make legacy events dispatched for default prevented wheel "
"event, you need to initialize stateX and stateY" ")", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 2844); AnnotateMozCrashReason("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" ")"); do {
*((volatile int*)__null) = 2844; __attribute__((nomerge)) ::
abort(); } while (false); } } while (false)
;
2845 EventState stateX, stateY;
2846 if (scrollDeltaY) {
2847 SendLineScrollEvent(aTargetFrame, aEvent, stateY, scrollDeltaY,
2848 DELTA_DIRECTION_Y);
2849 if (!targetFrame.IsAlive()) {
2850 *aStatus = nsEventStatus_eConsumeNoDefault;
2851 return;
2852 }
2853 }
2854
2855 if (pixelDeltaY) {
2856 SendPixelScrollEvent(aTargetFrame, aEvent, stateY, pixelDeltaY,
2857 DELTA_DIRECTION_Y);
2858 if (!targetFrame.IsAlive()) {
2859 *aStatus = nsEventStatus_eConsumeNoDefault;
2860 return;
2861 }
2862 }
2863
2864 if (scrollDeltaX) {
2865 SendLineScrollEvent(aTargetFrame, aEvent, stateX, scrollDeltaX,
2866 DELTA_DIRECTION_X);
2867 if (!targetFrame.IsAlive()) {
2868 *aStatus = nsEventStatus_eConsumeNoDefault;
2869 return;
2870 }
2871 }
2872
2873 if (pixelDeltaX) {
2874 SendPixelScrollEvent(aTargetFrame, aEvent, stateX, pixelDeltaX,
2875 DELTA_DIRECTION_X);
2876 if (!targetFrame.IsAlive()) {
2877 *aStatus = nsEventStatus_eConsumeNoDefault;
2878 return;
2879 }
2880 }
2881
2882 if (stateY.mDefaultPrevented) {
2883 *aStatus = nsEventStatus_eConsumeNoDefault;
2884 aEvent->PreventDefault(!stateY.mDefaultPreventedByContent);
2885 }
2886
2887 if (stateX.mDefaultPrevented) {
2888 *aStatus = nsEventStatus_eConsumeNoDefault;
2889 aEvent->PreventDefault(!stateX.mDefaultPreventedByContent);
2890 }
2891}
2892
2893void EventStateManager::SendLineScrollEvent(nsIFrame* aTargetFrame,
2894 WidgetWheelEvent* aEvent,
2895 EventState& aState, int32_t aDelta,
2896 DeltaDirection aDeltaDirection) {
2897 nsCOMPtr<nsIContent> targetContent = aTargetFrame->GetContent();
2898 if (!targetContent) {
2899 targetContent = GetFocusedElement();
2900 if (!targetContent) {
2901 return;
2902 }
2903 }
2904
2905 while (targetContent->IsText()) {
2906 targetContent = targetContent->GetFlattenedTreeParent();
2907 }
2908
2909 WidgetMouseScrollEvent event(aEvent->IsTrusted(),
2910 eLegacyMouseLineOrPageScroll, aEvent->mWidget);
2911 event.mFlags.mDefaultPrevented = aState.mDefaultPrevented;
2912 event.mFlags.mDefaultPreventedByContent = aState.mDefaultPreventedByContent;
2913 event.mRefPoint = aEvent->mRefPoint;
2914 event.mTimeStamp = aEvent->mTimeStamp;
2915 event.mModifiers = aEvent->mModifiers;
2916 event.mButtons = aEvent->mButtons;
2917 event.mIsHorizontal = (aDeltaDirection == DELTA_DIRECTION_X);
2918 event.mDelta = aDelta;
2919 event.mInputSource = aEvent->mInputSource;
2920
2921 RefPtr<nsPresContext> presContext = aTargetFrame->PresContext();
2922 nsEventStatus status = nsEventStatus_eIgnore;
2923 EventDispatcher::Dispatch(targetContent, presContext, &event, nullptr,
2924 &status);
2925 aState.mDefaultPrevented =
2926 event.DefaultPrevented() || status == nsEventStatus_eConsumeNoDefault;
2927 aState.mDefaultPreventedByContent = event.DefaultPreventedByContent();
2928}
2929
2930void EventStateManager::SendPixelScrollEvent(nsIFrame* aTargetFrame,
2931 WidgetWheelEvent* aEvent,
2932 EventState& aState,
2933 int32_t aPixelDelta,
2934 DeltaDirection aDeltaDirection) {
2935 nsCOMPtr<nsIContent> targetContent = aTargetFrame->GetContent();
2936 if (!targetContent) {
2937 targetContent = GetFocusedElement();
2938 if (!targetContent) {
2939 return;
2940 }
2941 }
2942
2943 while (targetContent->IsText()) {
2944 targetContent = targetContent->GetFlattenedTreeParent();
2945 }
2946
2947 WidgetMouseScrollEvent event(aEvent->IsTrusted(), eLegacyMousePixelScroll,
2948 aEvent->mWidget);
2949 event.mFlags.mDefaultPrevented = aState.mDefaultPrevented;
2950 event.mFlags.mDefaultPreventedByContent = aState.mDefaultPreventedByContent;
2951 event.mRefPoint = aEvent->mRefPoint;
2952 event.mTimeStamp = aEvent->mTimeStamp;
2953 event.mModifiers = aEvent->mModifiers;
2954 event.mButtons = aEvent->mButtons;
2955 event.mIsHorizontal = (aDeltaDirection == DELTA_DIRECTION_X);
2956 event.mDelta = aPixelDelta;
2957 event.mInputSource = aEvent->mInputSource;
2958
2959 RefPtr<nsPresContext> presContext = aTargetFrame->PresContext();
2960 nsEventStatus status = nsEventStatus_eIgnore;
2961 EventDispatcher::Dispatch(targetContent, presContext, &event, nullptr,
2962 &status);
2963 aState.mDefaultPrevented =
2964 event.DefaultPrevented() || status == nsEventStatus_eConsumeNoDefault;
2965 aState.mDefaultPreventedByContent = event.DefaultPreventedByContent();
2966}
2967
2968nsIFrame* EventStateManager::ComputeScrollTargetAndMayAdjustWheelEvent(
2969 nsIFrame* aTargetFrame, WidgetWheelEvent* aEvent,
2970 ComputeScrollTargetOptions aOptions) {
2971 return ComputeScrollTargetAndMayAdjustWheelEvent(
2972 aTargetFrame, aEvent->mDeltaX, aEvent->mDeltaY, aEvent, aOptions);
2973}
2974
2975// Overload ComputeScrollTargetAndMayAdjustWheelEvent method to allow passing
2976// "test" dx and dy when looking for which scrollbarmediators to activate when
2977// two finger down on trackpad and before any actual motion
2978nsIFrame* EventStateManager::ComputeScrollTargetAndMayAdjustWheelEvent(
2979 nsIFrame* aTargetFrame, double aDirectionX, double aDirectionY,
2980 WidgetWheelEvent* aEvent, ComputeScrollTargetOptions aOptions) {
2981 bool isAutoDir = false;
2982 bool honoursRoot = false;
2983 if (MAY_BE_ADJUSTED_BY_AUTO_DIR & aOptions) {
2984 // If the scroll is respected as auto-dir, aDirection* should always be
2985 // equivalent to the event's delta vlaues(Currently, there are only one case
2986 // where aDirection*s have different values from the widget wheel event's
2987 // original delta values and the only case isn't auto-dir, see
2988 // ScrollbarsForWheel::TemporarilyActivateAllPossibleScrollTargets).
2989 MOZ_ASSERT(aDirectionX == aEvent->mDeltaX &&do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aDirectionX == aEvent->mDeltaX && aDirectionY
== aEvent->mDeltaY)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aDirectionX == aEvent->mDeltaX
&& aDirectionY == aEvent->mDeltaY))), 0))) { do {
} while (false); MOZ_ReportAssertionFailure("aDirectionX == aEvent->mDeltaX && aDirectionY == aEvent->mDeltaY"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 2990); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aDirectionX == aEvent->mDeltaX && aDirectionY == aEvent->mDeltaY"
")"); do { *((volatile int*)__null) = 2990; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
2990 aDirectionY == aEvent->mDeltaY)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aDirectionX == aEvent->mDeltaX && aDirectionY
== aEvent->mDeltaY)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aDirectionX == aEvent->mDeltaX
&& aDirectionY == aEvent->mDeltaY))), 0))) { do {
} while (false); MOZ_ReportAssertionFailure("aDirectionX == aEvent->mDeltaX && aDirectionY == aEvent->mDeltaY"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 2990); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aDirectionX == aEvent->mDeltaX && aDirectionY == aEvent->mDeltaY"
")"); do { *((volatile int*)__null) = 2990; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
2991
2992 WheelDeltaAdjustmentStrategy strategy =
2993 GetWheelDeltaAdjustmentStrategy(*aEvent);
2994 switch (strategy) {
2995 case WheelDeltaAdjustmentStrategy::eAutoDir:
2996 isAutoDir = true;
2997 honoursRoot = false;
2998 break;
2999 case WheelDeltaAdjustmentStrategy::eAutoDirWithRootHonour:
3000 isAutoDir = true;
3001 honoursRoot = true;
3002 break;
3003 default:
3004 break;
3005 }
3006 }
3007
3008 if (aOptions & PREFER_MOUSE_WHEEL_TRANSACTION) {
3009 // If the user recently scrolled with the mousewheel, then they probably
3010 // want to scroll the same view as before instead of the view under the
3011 // cursor. WheelTransaction tracks the frame currently being
3012 // scrolled with the mousewheel. We consider the transaction ended when the
3013 // mouse moves more than "mousewheel.transaction.ignoremovedelay"
3014 // milliseconds after the last scroll operation, or any time the mouse moves
3015 // out of the frame, or when more than "mousewheel.transaction.timeout"
3016 // milliseconds have passed after the last operation, even if the mouse
3017 // hasn't moved.
3018 nsIFrame* lastScrollFrame = WheelTransaction::GetScrollTargetFrame();
3019 if (lastScrollFrame) {
3020 nsIScrollableFrame* scrollableFrame =
3021 lastScrollFrame->GetScrollTargetFrame();
3022 if (scrollableFrame) {
3023 nsIFrame* frameToScroll = do_QueryFrame(scrollableFrame);
3024 MOZ_ASSERT(frameToScroll)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(frameToScroll)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(frameToScroll))), 0))) { do {
} while (false); MOZ_ReportAssertionFailure("frameToScroll",
"/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 3024); AnnotateMozCrashReason("MOZ_ASSERT" "(" "frameToScroll"
")"); do { *((volatile int*)__null) = 3024; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
3025 if (isAutoDir) {
3026 ESMAutoDirWheelDeltaAdjuster adjuster(*aEvent, *lastScrollFrame,
3027 honoursRoot);
3028 // Note that calling this function will not always cause the delta to
3029 // be adjusted, it only adjusts the delta when it should, because
3030 // Adjust() internally calls ShouldBeAdjusted() before making
3031 // adjustment.
3032 adjuster.Adjust();
3033 }
3034 return frameToScroll;
3035 }
3036 }
3037 }
3038
3039 // If the event doesn't cause scroll actually, we cannot find scroll target
3040 // because we check if the event can cause scroll actually on each found
3041 // scrollable frame.
3042 if (!aDirectionX && !aDirectionY) {
3043 return nullptr;
3044 }
3045
3046 bool checkIfScrollableX;
3047 bool checkIfScrollableY;
3048 if (isAutoDir) {
3049 // Always check the frame's scrollability in both the two directions for an
3050 // auto-dir scroll. That is, for an auto-dir scroll,
3051 // PREFER_ACTUAL_SCROLLABLE_TARGET_ALONG_X_AXIS and
3052 // PREFER_ACTUAL_SCROLLABLE_TARGET_ALONG_Y_AXIS should be ignored.
3053 checkIfScrollableX = true;
3054 checkIfScrollableY = true;
3055 } else {
3056 checkIfScrollableX =
3057 aDirectionX &&
3058 (aOptions & PREFER_ACTUAL_SCROLLABLE_TARGET_ALONG_X_AXIS);
3059 checkIfScrollableY =
3060 aDirectionY &&
3061 (aOptions & PREFER_ACTUAL_SCROLLABLE_TARGET_ALONG_Y_AXIS);
3062 }
3063
3064 nsIFrame* scrollFrame = !(aOptions & START_FROM_PARENT)
3065 ? aTargetFrame
3066 : GetParentFrameToScroll(aTargetFrame);
3067 for (; scrollFrame; scrollFrame = GetParentFrameToScroll(scrollFrame)) {
3068 // Check whether the frame wants to provide us with a scrollable view.
3069 nsIScrollableFrame* scrollableFrame = scrollFrame->GetScrollTargetFrame();
3070 if (!scrollableFrame) {
3071 nsMenuPopupFrame* menuPopupFrame = do_QueryFrame(scrollFrame);
3072 if (menuPopupFrame) {
3073 return nullptr;
3074 }
3075 continue;
3076 }
3077
3078 nsIFrame* frameToScroll = do_QueryFrame(scrollableFrame);
3079 MOZ_ASSERT(frameToScroll)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(frameToScroll)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(frameToScroll))), 0))) { do {
} while (false); MOZ_ReportAssertionFailure("frameToScroll",
"/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 3079); AnnotateMozCrashReason("MOZ_ASSERT" "(" "frameToScroll"
")"); do { *((volatile int*)__null) = 3079; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
3080
3081 if (!checkIfScrollableX && !checkIfScrollableY) {
3082 return frameToScroll;
3083 }
3084
3085 // If the frame disregards the direction the user is trying to scroll, then
3086 // it should just bubbles the scroll event up to its parental scroll frame
3087
3088 Maybe<layers::ScrollDirection> disregardedDirection =
3089 WheelHandlingUtils::GetDisregardedWheelScrollDirection(scrollFrame);
3090 if (disregardedDirection) {
3091 switch (disregardedDirection.ref()) {
3092 case layers::ScrollDirection::eHorizontal:
3093 if (checkIfScrollableX) {
3094 continue;
3095 }
3096 break;
3097 case layers::ScrollDirection::eVertical:
3098 if (checkIfScrollableY) {
3099 continue;
3100 }
3101 break;
3102 }
3103 }
3104
3105 layers::ScrollDirections directions =
3106 scrollableFrame->GetAvailableScrollingDirectionsForUserInputEvents();
3107 if ((!(directions.contains(layers::ScrollDirection::eVertical)) &&
3108 !(directions.contains(layers::ScrollDirection::eHorizontal))) ||
3109 (checkIfScrollableY && !checkIfScrollableX &&
3110 !(directions.contains(layers::ScrollDirection::eVertical))) ||
3111 (checkIfScrollableX && !checkIfScrollableY &&
3112 !(directions.contains(layers::ScrollDirection::eHorizontal)))) {
3113 continue;
3114 }
3115
3116 // Computes whether the currently checked frame is scrollable by this wheel
3117 // event.
3118 bool canScroll = false;
3119 if (isAutoDir) {
3120 ESMAutoDirWheelDeltaAdjuster adjuster(*aEvent, *scrollFrame, honoursRoot);
3121 if (adjuster.ShouldBeAdjusted()) {
3122 adjuster.Adjust();
3123 canScroll = true;
3124 } else if (WheelHandlingUtils::CanScrollOn(scrollableFrame, aDirectionX,
3125 aDirectionY)) {
3126 canScroll = true;
3127 }
3128 } else if (WheelHandlingUtils::CanScrollOn(scrollableFrame, aDirectionX,
3129 aDirectionY)) {
3130 canScroll = true;
3131 }
3132
3133 if (canScroll) {
3134 return frameToScroll;
3135 }
3136
3137 // Where we are at is the block ending in a for loop.
3138 // The current frame has been checked to be unscrollable by this wheel
3139 // event, continue the loop to check its parent, if any.
3140 }
3141
3142 nsIFrame* newFrame = nsLayoutUtils::GetCrossDocParentFrameInProcess(
3143 aTargetFrame->PresShell()->GetRootFrame());
3144 aOptions =
3145 static_cast<ComputeScrollTargetOptions>(aOptions & ~START_FROM_PARENT);
3146 if (!newFrame) {
3147 return nullptr;
3148 }
3149 return ComputeScrollTargetAndMayAdjustWheelEvent(newFrame, aEvent, aOptions);
3150}
3151
3152nsSize EventStateManager::GetScrollAmount(
3153 nsPresContext* aPresContext, WidgetWheelEvent* aEvent,
3154 nsIScrollableFrame* aScrollableFrame) {
3155 MOZ_ASSERT(aPresContext)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aPresContext)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aPresContext))), 0))) { do {
} while (false); MOZ_ReportAssertionFailure("aPresContext", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 3155); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aPresContext"
")"); do { *((volatile int*)__null) = 3155; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
3156 MOZ_ASSERT(aEvent)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aEvent)>::isValid, "invalid assertion condition")
; if ((__builtin_expect(!!(!(!!(aEvent))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("aEvent", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 3156); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aEvent" ")"
); do { *((volatile int*)__null) = 3156; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
3157
3158 const bool isPage = aEvent->mDeltaMode == WheelEvent_Binding::DOM_DELTA_PAGE;
3159 if (!aScrollableFrame) {
3160 // If there is no scrollable frame, we should use root, see below.
3161 aScrollableFrame =
3162 aPresContext->PresShell()->GetRootScrollFrameAsScrollable();
3163 }
3164
3165 if (aScrollableFrame) {
3166 return isPage ? aScrollableFrame->GetPageScrollAmount()
3167 : aScrollableFrame->GetLineScrollAmount();
3168 }
3169
3170 // If there is no scrollable frame and page scrolling, use viewport size.
3171 if (isPage) {
3172 return aPresContext->GetVisibleArea().Size();
3173 }
3174
3175 // Otherwise use root frame's font metrics.
3176 //
3177 // FIXME(emilio): Should this use the root element's style frame? The root
3178 // frame will always have the initial font. Then again it should never matter
3179 // for content, we should always have a root scrollable frame in html
3180 // documents.
3181 nsIFrame* rootFrame = aPresContext->PresShell()->GetRootFrame();
3182 if (!rootFrame) {
3183 return nsSize(0, 0);
3184 }
3185 RefPtr<nsFontMetrics> fm =
3186 nsLayoutUtils::GetInflatedFontMetricsForFrame(rootFrame);
3187 NS_ENSURE_TRUE(fm, nsSize(0, 0))do { if ((__builtin_expect(!!(!(fm)), 0))) { NS_DebugBreak(NS_DEBUG_WARNING
, "NS_ENSURE_TRUE(" "fm" ") failed", nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 3187); return nsSize(0, 0); } } while (false)
;
3188 return nsSize(fm->AveCharWidth(), fm->MaxHeight());
3189}
3190
3191void EventStateManager::DoScrollText(nsIScrollableFrame* aScrollableFrame,
3192 WidgetWheelEvent* aEvent) {
3193 MOZ_ASSERT(aScrollableFrame)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aScrollableFrame)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aScrollableFrame))), 0))) { do
{ } while (false); MOZ_ReportAssertionFailure("aScrollableFrame"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 3193); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aScrollableFrame"
")"); do { *((volatile int*)__null) = 3193; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
3194 MOZ_ASSERT(aEvent)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aEvent)>::isValid, "invalid assertion condition")
; if ((__builtin_expect(!!(!(!!(aEvent))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("aEvent", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 3194); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aEvent" ")"
); do { *((volatile int*)__null) = 3194; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
3195
3196 nsIFrame* scrollFrame = do_QueryFrame(aScrollableFrame);
3197 MOZ_ASSERT(scrollFrame)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(scrollFrame)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(scrollFrame))), 0))) { do { }
while (false); MOZ_ReportAssertionFailure("scrollFrame", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 3197); AnnotateMozCrashReason("MOZ_ASSERT" "(" "scrollFrame"
")"); do { *((volatile int*)__null) = 3197; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
3198
3199 AutoWeakFrame scrollFrameWeak(scrollFrame);
3200 AutoWeakFrame eventFrameWeak(mCurrentTarget);
3201 if (!WheelTransaction::WillHandleDefaultAction(aEvent, scrollFrameWeak,
3202 eventFrameWeak)) {
3203 return;
3204 }
3205
3206 // Default action's actual scroll amount should be computed from device
3207 // pixels.
3208 nsPresContext* pc = scrollFrame->PresContext();
3209 nsSize scrollAmount = GetScrollAmount(pc, aEvent, aScrollableFrame);
3210 nsIntSize scrollAmountInDevPixels(
3211 pc->AppUnitsToDevPixels(scrollAmount.width),
3212 pc->AppUnitsToDevPixels(scrollAmount.height));
3213 nsIntPoint actualDevPixelScrollAmount =
3214 DeltaAccumulator::GetInstance()->ComputeScrollAmountForDefaultAction(
3215 aEvent, scrollAmountInDevPixels);
3216
3217 // Don't scroll around the axis whose overflow style is hidden.
3218 ScrollStyles overflowStyle = aScrollableFrame->GetScrollStyles();
3219 if (overflowStyle.mHorizontal == StyleOverflow::Hidden) {
3220 actualDevPixelScrollAmount.x = 0;
3221 }
3222 if (overflowStyle.mVertical == StyleOverflow::Hidden) {
3223 actualDevPixelScrollAmount.y = 0;
3224 }
3225
3226 ScrollSnapFlags snapFlags = ScrollSnapFlags::Disabled;
3227 mozilla::ScrollOrigin origin = mozilla::ScrollOrigin::NotSpecified;
3228 switch (aEvent->mDeltaMode) {
3229 case WheelEvent_Binding::DOM_DELTA_LINE:
3230 origin = mozilla::ScrollOrigin::MouseWheel;
3231 snapFlags = ScrollSnapFlags::IntendedDirection;
3232 break;
3233 case WheelEvent_Binding::DOM_DELTA_PAGE:
3234 origin = mozilla::ScrollOrigin::Pages;
3235 snapFlags = ScrollSnapFlags::IntendedDirection |
3236 ScrollSnapFlags::IntendedEndPosition;
3237 break;
3238 case WheelEvent_Binding::DOM_DELTA_PIXEL:
3239 origin = mozilla::ScrollOrigin::Pixels;
3240 break;
3241 default:
3242 MOZ_CRASH("Invalid deltaMode value comes")do { do { } while (false); MOZ_ReportCrash("" "Invalid deltaMode value comes"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 3242); AnnotateMozCrashReason("MOZ_CRASH(" "Invalid deltaMode value comes"
")"); do { *((volatile int*)__null) = 3242; __attribute__((nomerge
)) ::abort(); } while (false); } while (false)
;
3243 }
3244
3245 // We shouldn't scroll more one page at once except when over one page scroll
3246 // is allowed for the event.
3247 nsSize pageSize = aScrollableFrame->GetPageScrollAmount();
3248 nsIntSize devPixelPageSize(pc->AppUnitsToDevPixels(pageSize.width),
3249 pc->AppUnitsToDevPixels(pageSize.height));
3250 if (!WheelPrefs::GetInstance()->IsOverOnePageScrollAllowedX(aEvent) &&
3251 DeprecatedAbs(actualDevPixelScrollAmount.x.value) >
3252 devPixelPageSize.width) {
3253 actualDevPixelScrollAmount.x = (actualDevPixelScrollAmount.x >= 0)
3254 ? devPixelPageSize.width
3255 : -devPixelPageSize.width;
3256 }
3257
3258 if (!WheelPrefs::GetInstance()->IsOverOnePageScrollAllowedY(aEvent) &&
3259 DeprecatedAbs(actualDevPixelScrollAmount.y.value) >
3260 devPixelPageSize.height) {
3261 actualDevPixelScrollAmount.y = (actualDevPixelScrollAmount.y >= 0)
3262 ? devPixelPageSize.height
3263 : -devPixelPageSize.height;
3264 }
3265
3266 bool isDeltaModePixel =
3267 (aEvent->mDeltaMode == WheelEvent_Binding::DOM_DELTA_PIXEL);
3268
3269 ScrollMode mode;
3270 switch (aEvent->mScrollType) {
3271 case WidgetWheelEvent::SCROLL_DEFAULT:
3272 if (isDeltaModePixel) {
3273 mode = ScrollMode::Normal;
3274 } else if (aEvent->mFlags.mHandledByAPZ) {
3275 mode = ScrollMode::SmoothMsd;
3276 } else {
3277 mode = ScrollMode::Smooth;
3278 }
3279 break;
3280 case WidgetWheelEvent::SCROLL_SYNCHRONOUSLY:
3281 mode = ScrollMode::Instant;
3282 break;
3283 case WidgetWheelEvent::SCROLL_ASYNCHRONOUSLY:
3284 mode = ScrollMode::Normal;
3285 break;
3286 case WidgetWheelEvent::SCROLL_SMOOTHLY:
3287 mode = ScrollMode::Smooth;
3288 break;
3289 default:
3290 MOZ_CRASH("Invalid mScrollType value comes")do { do { } while (false); MOZ_ReportCrash("" "Invalid mScrollType value comes"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 3290); AnnotateMozCrashReason("MOZ_CRASH(" "Invalid mScrollType value comes"
")"); do { *((volatile int*)__null) = 3290; __attribute__((nomerge
)) ::abort(); } while (false); } while (false)
;
3291 }
3292
3293 nsIScrollableFrame::ScrollMomentum momentum =
3294 aEvent->mIsMomentum ? nsIScrollableFrame::SYNTHESIZED_MOMENTUM_EVENT
3295 : nsIScrollableFrame::NOT_MOMENTUM;
3296
3297 nsIntPoint overflow;
3298 aScrollableFrame->ScrollBy(actualDevPixelScrollAmount,
3299 ScrollUnit::DEVICE_PIXELS, mode, &overflow, origin,
3300 momentum, snapFlags);
3301
3302 if (!scrollFrameWeak.IsAlive()) {
3303 // If the scroll causes changing the layout, we can think that the event
3304 // has been completely consumed by the content. Then, users probably don't
3305 // want additional action.
3306 aEvent->mOverflowDeltaX = aEvent->mOverflowDeltaY = 0;
3307 } else if (isDeltaModePixel) {
3308 aEvent->mOverflowDeltaX = overflow.x;
3309 aEvent->mOverflowDeltaY = overflow.y;
3310 } else {
3311 aEvent->mOverflowDeltaX =
3312 static_cast<double>(overflow.x) / scrollAmountInDevPixels.width;
3313 aEvent->mOverflowDeltaY =
3314 static_cast<double>(overflow.y) / scrollAmountInDevPixels.height;
3315 }
3316
3317 // If CSS overflow properties caused not to scroll, the overflowDelta* values
3318 // should be same as delta* values since they may be used as gesture event by
3319 // widget. However, if there is another scrollable element in the ancestor
3320 // along the axis, probably users don't want the operation to cause
3321 // additional action such as moving history. In such case, overflowDelta
3322 // values should stay zero.
3323 if (scrollFrameWeak.IsAlive()) {
3324 if (aEvent->mDeltaX && overflowStyle.mHorizontal == StyleOverflow::Hidden &&
3325 !ComputeScrollTargetAndMayAdjustWheelEvent(
3326 scrollFrame, aEvent,
3327 COMPUTE_SCROLLABLE_ANCESTOR_ALONG_X_AXIS_WITH_AUTO_DIR)) {
3328 aEvent->mOverflowDeltaX = aEvent->mDeltaX;
3329 }
3330 if (aEvent->mDeltaY && overflowStyle.mVertical == StyleOverflow::Hidden &&
3331 !ComputeScrollTargetAndMayAdjustWheelEvent(
3332 scrollFrame, aEvent,
3333 COMPUTE_SCROLLABLE_ANCESTOR_ALONG_Y_AXIS_WITH_AUTO_DIR)) {
3334 aEvent->mOverflowDeltaY = aEvent->mDeltaY;
3335 }
3336 }
3337
3338 NS_ASSERTION(do { if (!(aEvent->mOverflowDeltaX == 0 || (aEvent->mOverflowDeltaX
> 0) == (aEvent->mDeltaX > 0))) { NS_DebugBreak(NS_DEBUG_ASSERTION
, "The sign of mOverflowDeltaX is different from the scroll direction"
, "aEvent->mOverflowDeltaX == 0 || (aEvent->mOverflowDeltaX > 0) == (aEvent->mDeltaX > 0)"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 3341); MOZ_PretendNoReturn(); } } while (0)
3339 aEvent->mOverflowDeltaX == 0 ||do { if (!(aEvent->mOverflowDeltaX == 0 || (aEvent->mOverflowDeltaX
> 0) == (aEvent->mDeltaX > 0))) { NS_DebugBreak(NS_DEBUG_ASSERTION
, "The sign of mOverflowDeltaX is different from the scroll direction"
, "aEvent->mOverflowDeltaX == 0 || (aEvent->mOverflowDeltaX > 0) == (aEvent->mDeltaX > 0)"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 3341); MOZ_PretendNoReturn(); } } while (0)
3340 (aEvent->mOverflowDeltaX > 0) == (aEvent->mDeltaX > 0),do { if (!(aEvent->mOverflowDeltaX == 0 || (aEvent->mOverflowDeltaX
> 0) == (aEvent->mDeltaX > 0))) { NS_DebugBreak(NS_DEBUG_ASSERTION
, "The sign of mOverflowDeltaX is different from the scroll direction"
, "aEvent->mOverflowDeltaX == 0 || (aEvent->mOverflowDeltaX > 0) == (aEvent->mDeltaX > 0)"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 3341); MOZ_PretendNoReturn(); } } while (0)
3341 "The sign of mOverflowDeltaX is different from the scroll direction")do { if (!(aEvent->mOverflowDeltaX == 0 || (aEvent->mOverflowDeltaX
> 0) == (aEvent->mDeltaX > 0))) { NS_DebugBreak(NS_DEBUG_ASSERTION
, "The sign of mOverflowDeltaX is different from the scroll direction"
, "aEvent->mOverflowDeltaX == 0 || (aEvent->mOverflowDeltaX > 0) == (aEvent->mDeltaX > 0)"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 3341); MOZ_PretendNoReturn(); } } while (0)
;
3342 NS_ASSERTION(do { if (!(aEvent->mOverflowDeltaY == 0 || (aEvent->mOverflowDeltaY
> 0) == (aEvent->mDeltaY > 0))) { NS_DebugBreak(NS_DEBUG_ASSERTION
, "The sign of mOverflowDeltaY is different from the scroll direction"
, "aEvent->mOverflowDeltaY == 0 || (aEvent->mOverflowDeltaY > 0) == (aEvent->mDeltaY > 0)"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 3345); MOZ_PretendNoReturn(); } } while (0)
3343 aEvent->mOverflowDeltaY == 0 ||do { if (!(aEvent->mOverflowDeltaY == 0 || (aEvent->mOverflowDeltaY
> 0) == (aEvent->mDeltaY > 0))) { NS_DebugBreak(NS_DEBUG_ASSERTION
, "The sign of mOverflowDeltaY is different from the scroll direction"
, "aEvent->mOverflowDeltaY == 0 || (aEvent->mOverflowDeltaY > 0) == (aEvent->mDeltaY > 0)"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 3345); MOZ_PretendNoReturn(); } } while (0)
3344 (aEvent->mOverflowDeltaY > 0) == (aEvent->mDeltaY > 0),do { if (!(aEvent->mOverflowDeltaY == 0 || (aEvent->mOverflowDeltaY
> 0) == (aEvent->mDeltaY > 0))) { NS_DebugBreak(NS_DEBUG_ASSERTION
, "The sign of mOverflowDeltaY is different from the scroll direction"
, "aEvent->mOverflowDeltaY == 0 || (aEvent->mOverflowDeltaY > 0) == (aEvent->mDeltaY > 0)"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 3345); MOZ_PretendNoReturn(); } } while (0)
3345 "The sign of mOverflowDeltaY is different from the scroll direction")do { if (!(aEvent->mOverflowDeltaY == 0 || (aEvent->mOverflowDeltaY
> 0) == (aEvent->mDeltaY > 0))) { NS_DebugBreak(NS_DEBUG_ASSERTION
, "The sign of mOverflowDeltaY is different from the scroll direction"
, "aEvent->mOverflowDeltaY == 0 || (aEvent->mOverflowDeltaY > 0) == (aEvent->mDeltaY > 0)"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 3345); MOZ_PretendNoReturn(); } } while (0)
;
3346
3347 WheelPrefs::GetInstance()->CancelApplyingUserPrefsFromOverflowDelta(aEvent);
3348}
3349
3350void EventStateManager::DecideGestureEvent(WidgetGestureNotifyEvent* aEvent,
3351 nsIFrame* targetFrame) {
3352 NS_ASSERTION(aEvent->mMessage == eGestureNotify,do { if (!(aEvent->mMessage == eGestureNotify)) { NS_DebugBreak
(NS_DEBUG_ASSERTION, "DecideGestureEvent called with a non-gesture event"
, "aEvent->mMessage == eGestureNotify", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 3353); MOZ_PretendNoReturn(); } } while (0)
3353 "DecideGestureEvent called with a non-gesture event")do { if (!(aEvent->mMessage == eGestureNotify)) { NS_DebugBreak
(NS_DEBUG_ASSERTION, "DecideGestureEvent called with a non-gesture event"
, "aEvent->mMessage == eGestureNotify", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 3353); MOZ_PretendNoReturn(); } } while (0)
;
3354
3355 /* Check the ancestor tree to decide if any frame is willing* to receive
3356 * a MozPixelScroll event. If that's the case, the current touch gesture
3357 * will be used as a pan gesture; otherwise it will be a regular
3358 * mousedown/mousemove/click event.
3359 *
3360 * *willing: determine if it makes sense to pan the element using scroll
3361 * events:
3362 * - For web content: if there are any visible scrollbars on the touch point
3363 * - For XUL: if it's an scrollable element that can currently scroll in some
3364 * direction.
3365 *
3366 * Note: we'll have to one-off various cases to ensure a good usable behavior
3367 */
3368 WidgetGestureNotifyEvent::PanDirection panDirection =
3369 WidgetGestureNotifyEvent::ePanNone;
3370 bool displayPanFeedback = false;
3371 for (nsIFrame* current = targetFrame; current;
3372 current = nsLayoutUtils::GetCrossDocParentFrame(current)) {
3373 // e10s - mark remote content as pannable. This is a work around since
3374 // we don't have access to remote frame scroll info here. Apz data may
3375 // assist is solving this.
3376 if (current && IsTopLevelRemoteTarget(current->GetContent())) {
3377 panDirection = WidgetGestureNotifyEvent::ePanBoth;
3378 // We don't know when we reach bounds, so just disable feedback for now.
3379 displayPanFeedback = false;
3380 break;
3381 }
3382
3383 LayoutFrameType currentFrameType = current->Type();
3384
3385 // Scrollbars should always be draggable
3386 if (currentFrameType == LayoutFrameType::Scrollbar) {
3387 panDirection = WidgetGestureNotifyEvent::ePanNone;
3388 break;
3389 }
3390
3391 // Special check for trees
3392 if (nsTreeBodyFrame* treeFrame = do_QueryFrame(current)) {
3393 if (treeFrame->GetHorizontalOverflow()) {
3394 panDirection = WidgetGestureNotifyEvent::ePanHorizontal;
3395 }
3396 if (treeFrame->GetVerticalOverflow()) {
3397 panDirection = WidgetGestureNotifyEvent::ePanVertical;
3398 }
3399 break;
3400 }
3401
3402 if (nsIScrollableFrame* scrollableFrame = do_QueryFrame(current)) {
3403 layers::ScrollDirections scrollbarVisibility =
3404 scrollableFrame->GetScrollbarVisibility();
3405
3406 // Check if we have visible scrollbars
3407 if (scrollbarVisibility.contains(layers::ScrollDirection::eVertical)) {
3408 panDirection = WidgetGestureNotifyEvent::ePanVertical;
3409 displayPanFeedback = true;
3410 break;
3411 }
3412
3413 if (scrollbarVisibility.contains(layers::ScrollDirection::eHorizontal)) {
3414 panDirection = WidgetGestureNotifyEvent::ePanHorizontal;
3415 displayPanFeedback = true;
3416 }
3417 } // scrollableFrame
3418 } // ancestor chain
3419 aEvent->mDisplayPanFeedback = displayPanFeedback;
3420 aEvent->mPanDirection = panDirection;
3421}
3422
3423#ifdef XP_MACOSX
3424static nsINode* GetCrossDocParentNode(nsINode* aChild) {
3425 MOZ_ASSERT(aChild, "The child is null!")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aChild)>::isValid, "invalid assertion condition")
; if ((__builtin_expect(!!(!(!!(aChild))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("aChild" " (" "The child is null!"
")", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 3425); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aChild" ") ("
"The child is null!" ")"); do { *((volatile int*)__null) = 3425
; __attribute__((nomerge)) ::abort(); } while (false); } } while
(false)
;
3426 MOZ_ASSERT(XRE_IsParentProcess())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(XRE_IsParentProcess())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(XRE_IsParentProcess()))), 0)
)) { do { } while (false); MOZ_ReportAssertionFailure("XRE_IsParentProcess()"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 3426); AnnotateMozCrashReason("MOZ_ASSERT" "(" "XRE_IsParentProcess()"
")"); do { *((volatile int*)__null) = 3426; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
3427
3428 nsINode* parent = aChild->GetParentNode();
3429 if (parent && parent->IsContent() && aChild->IsContent()) {
3430 parent = aChild->AsContent()->GetFlattenedTreeParent();
3431 }
3432
3433 if (parent || !aChild->IsDocument()) {
3434 return parent;
3435 }
3436
3437 return aChild->AsDocument()->GetEmbedderElement();
3438}
3439
3440static bool NodeAllowsClickThrough(nsINode* aNode) {
3441 while (aNode) {
3442 if (aNode->IsAnyOfXULElements(nsGkAtoms::browser, nsGkAtoms::tree)) {
3443 return false;
3444 }
3445 if (aNode->IsAnyOfXULElements(nsGkAtoms::scrollbar, nsGkAtoms::resizer)) {
3446 return true;
3447 }
3448 aNode = GetCrossDocParentNode(aNode);
3449 }
3450 return true;
3451}
3452#endif
3453
3454void EventStateManager::PostHandleKeyboardEvent(
3455 WidgetKeyboardEvent* aKeyboardEvent, nsIFrame* aTargetFrame,
3456 nsEventStatus& aStatus) {
3457 if (aStatus == nsEventStatus_eConsumeNoDefault) {
3458 return;
3459 }
3460
3461 RefPtr<nsPresContext> presContext = mPresContext;
3462
3463 if (!aKeyboardEvent->HasBeenPostedToRemoteProcess()) {
3464 if (aKeyboardEvent->IsWaitingReplyFromRemoteProcess()) {
3465 RefPtr<BrowserParent> remote =
3466 aTargetFrame ? BrowserParent::GetFrom(aTargetFrame->GetContent())
3467 : nullptr;
3468 if (remote) {
3469 // remote is null-checked above in order to let pre-existing event
3470 // targeting code's chrome vs. content decision override in case of
3471 // disagreement in order not to disrupt non-Fission e10s mode in case
3472 // there are still bugs in the Fission-mode code. That is, if remote
3473 // is nullptr, the pre-existing event targeting code has deemed this
3474 // event to belong to chrome rather than content.
3475 BrowserParent* preciseRemote = BrowserParent::GetFocused();
3476 if (preciseRemote) {
3477 remote = preciseRemote;
3478 }
3479 // else there was a race between layout and focus tracking
3480 }
3481 if (remote && !remote->IsReadyToHandleInputEvents()) {
3482 // We need to dispatch the event to the browser element again if we were
3483 // waiting for the key reply but the event wasn't sent to the content
3484 // process due to the remote browser wasn't ready.
3485 WidgetKeyboardEvent keyEvent(*aKeyboardEvent);
3486 aKeyboardEvent->MarkAsHandledInRemoteProcess();
3487 RefPtr<Element> ownerElement = remote->GetOwnerElement();
3488 EventDispatcher::Dispatch(ownerElement, presContext, &keyEvent);
3489 if (keyEvent.DefaultPrevented()) {
3490 aKeyboardEvent->PreventDefault(!keyEvent.DefaultPreventedByContent());
3491 aStatus = nsEventStatus_eConsumeNoDefault;
3492 return;
3493 }
3494 }
3495 }
3496 // The widget expects a reply for every keyboard event. If the event wasn't
3497 // dispatched to a content process (non-e10s or no content process
3498 // running), we need to short-circuit here. Otherwise, we need to wait for
3499 // the content process to handle the event.
3500 if (aKeyboardEvent->mWidget) {
3501 aKeyboardEvent->mWidget->PostHandleKeyEvent(aKeyboardEvent);
3502 }
3503 if (aKeyboardEvent->DefaultPrevented()) {
3504 aStatus = nsEventStatus_eConsumeNoDefault;
3505 return;
3506 }
3507 }
3508
3509 // XXX Currently, our automated tests don't support mKeyNameIndex.
3510 // Therefore, we still need to handle this with keyCode.
3511 switch (aKeyboardEvent->mKeyCode) {
3512 case NS_VK_TAB:
3513 case NS_VK_F6:
3514 // This is to prevent keyboard scrolling while alt modifier in use.
3515 if (!aKeyboardEvent->IsAlt()) {
3516 aStatus = nsEventStatus_eConsumeNoDefault;
3517
3518 // Handling the tab event after it was sent to content is bad,
3519 // because to the FocusManager the remote-browser looks like one
3520 // element, so we would just move the focus to the next element
3521 // in chrome, instead of handling it in content.
3522 if (aKeyboardEvent->HasBeenPostedToRemoteProcess()) {
3523 break;
3524 }
3525
3526 EnsureDocument(presContext);
3527 nsFocusManager* fm = nsFocusManager::GetFocusManager();
3528 if (fm && mDocument) {
3529 // Shift focus forward or back depending on shift key
3530 bool isDocMove = aKeyboardEvent->IsControl() ||
3531 aKeyboardEvent->mKeyCode == NS_VK_F6;
3532 uint32_t dir =
3533 aKeyboardEvent->IsShift()
3534 ? (isDocMove ? static_cast<uint32_t>(
3535 nsIFocusManager::MOVEFOCUS_BACKWARDDOC)
3536 : static_cast<uint32_t>(
3537 nsIFocusManager::MOVEFOCUS_BACKWARD))
3538 : (isDocMove ? static_cast<uint32_t>(
3539 nsIFocusManager::MOVEFOCUS_FORWARDDOC)
3540 : static_cast<uint32_t>(
3541 nsIFocusManager::MOVEFOCUS_FORWARD));
3542 RefPtr<Element> result;
3543 fm->MoveFocus(mDocument->GetWindow(), nullptr, dir,
3544 nsIFocusManager::FLAG_BYKEY, getter_AddRefs(result));
3545 }
3546 }
3547 return;
3548 case 0:
3549 // We handle keys with no specific keycode value below.
3550 break;
3551 default:
3552 return;
3553 }
3554
3555 switch (aKeyboardEvent->mKeyNameIndex) {
3556 case KEY_NAME_INDEX_ZoomIn:
3557 case KEY_NAME_INDEX_ZoomOut:
3558 ChangeZoom(aKeyboardEvent->mKeyNameIndex == KEY_NAME_INDEX_ZoomIn);
3559 aStatus = nsEventStatus_eConsumeNoDefault;
3560 break;
3561 default:
3562 break;
3563 }
3564}
3565
3566static bool NeedsActiveContentChange(const WidgetMouseEvent* aMouseEvent) {
3567 // If the mouse event is a synthesized mouse event due to a touch, do
3568 // not set/clear the activation state. Element activation is handled by APZ.
3569 return !aMouseEvent ||
3570 aMouseEvent->mInputSource != MouseEvent_Binding::MOZ_SOURCE_TOUCH;
3571}
3572
3573nsresult EventStateManager::PostHandleEvent(nsPresContext* aPresContext,
3574 WidgetEvent* aEvent,
3575 nsIFrame* aTargetFrame,
3576 nsEventStatus* aStatus,
3577 nsIContent* aOverrideClickTarget) {
3578 NS_ENSURE_ARG(aPresContext)do { if ((__builtin_expect(!!(!(aPresContext)), 0))) { NS_DebugBreak
(NS_DEBUG_WARNING, "NS_ENSURE_TRUE(" "aPresContext" ") failed"
, nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 3578); return NS_ERROR_INVALID_ARG; } } while (false)
;
3579 NS_ENSURE_ARG_POINTER(aStatus)do { if ((__builtin_expect(!!(!(aStatus)), 0))) { NS_DebugBreak
(NS_DEBUG_WARNING, "NS_ENSURE_TRUE(" "aStatus" ") failed", nullptr
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 3579); return NS_ERROR_INVALID_POINTER; } } while (false)
;
3580
3581 mCurrentTarget = aTargetFrame;
3582 mCurrentTargetContent = nullptr;
3583
3584 HandleCrossProcessEvent(aEvent, aStatus);
3585 // NOTE: the above call may have destroyed aTargetFrame, please use
3586 // mCurrentTarget henceforth. This is to avoid using it accidentally:
3587 aTargetFrame = nullptr;
3588
3589 // Most of the events we handle below require a frame.
3590 // Add special cases here.
3591 if (!mCurrentTarget && aEvent->mMessage != eMouseUp &&
3592 aEvent->mMessage != eMouseDown && aEvent->mMessage != eDragEnter &&
3593 aEvent->mMessage != eDragOver && aEvent->mMessage != ePointerUp &&
3594 aEvent->mMessage != ePointerCancel) {
3595 return NS_OK;
3596 }
3597
3598 // Keep the prescontext alive, we might need it after event dispatch
3599 RefPtr<nsPresContext> presContext = aPresContext;
3600 nsresult ret = NS_OK;
3601
3602 switch (aEvent->mMessage) {
3603 case eMouseDown: {
3604 WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent();
3605 if (mouseEvent->mButton == MouseButton::ePrimary &&
3606 !sNormalLMouseEventInProcess) {
3607 // We got a mouseup event while a mousedown event was being processed.
3608 // Make sure that the capturing content is cleared.
3609 PresShell::ReleaseCapturingContent();
3610 break;
3611 }
3612
3613 // For remote content, capture the event in the parent process at the
3614 // <xul:browser remote> element. This will ensure that subsequent
3615 // mousemove/mouseup events will continue to be dispatched to this element
3616 // and therefore forwarded to the child.
3617 if (aEvent->HasBeenPostedToRemoteProcess() &&
3618 !PresShell::GetCapturingContent()) {
3619 if (nsIContent* content =
3620 mCurrentTarget ? mCurrentTarget->GetContent() : nullptr) {
3621 PresShell::SetCapturingContent(content, CaptureFlags::None, aEvent);
3622 } else {
3623 PresShell::ReleaseCapturingContent();
3624 }
3625 }
3626
3627 // If MouseEvent::PreventClickEvent() was called by chrome script,
3628 // we need to forget the clicking content and click count for the
3629 // following eMouseUp event.
3630 if (mouseEvent->mClickEventPrevented) {
3631 RefPtr<EventStateManager> esm =
3632 ESMFromContentOrThis(aOverrideClickTarget);
3633 switch (mouseEvent->mButton) {
3634 case MouseButton::ePrimary:
3635 case MouseButton::eSecondary:
3636 case MouseButton::eMiddle: {
3637 LastMouseDownInfo& mouseDownInfo =
3638 GetLastMouseDownInfo(mouseEvent->mButton);
3639 mouseDownInfo.mLastMouseDownContent = nullptr;
3640 mouseDownInfo.mClickCount = 0;
3641 mouseDownInfo.mLastMouseDownInputControlType = Nothing();
3642 break;
3643 }
3644
3645 default:
3646 break;
3647 }
3648 }
3649
3650 nsCOMPtr<nsIContent> activeContent;
3651 // When content calls PreventDefault on pointerdown, we also call
3652 // PreventDefault on the subsequent mouse events to suppress default
3653 // behaviors. Normally, aStatus should be nsEventStatus_eConsumeNoDefault
3654 // when the event is DefaultPrevented but it's reset to
3655 // nsEventStatus_eIgnore in EventStateManager::PreHandleEvent. So we also
3656 // check if the event is DefaultPrevented.
3657 if (nsEventStatus_eConsumeNoDefault != *aStatus &&
3658 !aEvent->DefaultPrevented()) {
3659 nsCOMPtr<nsIContent> newFocus;
3660 bool suppressBlur = false;
3661 if (mCurrentTarget) {
3662 mCurrentTarget->GetContentForEvent(aEvent, getter_AddRefs(newFocus));
3663 activeContent = mCurrentTarget->GetContent();
3664
3665 // In some cases, we do not want to even blur the current focused
3666 // element. Those cases are:
3667 // 1. -moz-user-focus CSS property is set to 'ignore';
3668 // 2. XUL control element has the disabled property set to 'true'.
3669 //
3670 // We can't use nsIFrame::IsFocusable() because we want to blur when
3671 // we click on a visibility: none element.
3672 // We can't use nsIContent::IsFocusable() because we want to blur when
3673 // we click on a non-focusable element like a <div>.
3674 // We have to use |aEvent->mTarget| to not make sure we do not check
3675 // an anonymous node of the targeted element.
3676 suppressBlur =
3677 mCurrentTarget->StyleUI()->UserFocus() == StyleUserFocus::Ignore;
3678
3679 if (!suppressBlur) {
3680 if (Element* element =
3681 Element::FromEventTargetOrNull(aEvent->mTarget)) {
3682 if (nsCOMPtr<nsIDOMXULControlElement> xulControl =
3683 element->AsXULControl()) {
3684 bool disabled = false;
3685 xulControl->GetDisabled(&disabled);
3686 suppressBlur = disabled;
3687 }
3688 }
3689 }
3690 }
3691
3692 // When a root content which isn't editable but has an editable HTML
3693 // <body> element is clicked, we should redirect the focus to the
3694 // the <body> element. E.g., when an user click bottom of the editor
3695 // where is outside of the <body> element, the <body> should be focused
3696 // and the user can edit immediately after that.
3697 //
3698 // NOTE: The newFocus isn't editable that also means it's not in
3699 // designMode. In designMode, all contents are not focusable.
3700 if (newFocus && !newFocus->IsEditable()) {
3701 Document* doc = newFocus->GetComposedDoc();
3702 if (doc && newFocus == doc->GetRootElement()) {
3703 nsIContent* bodyContent =
3704 nsLayoutUtils::GetEditableRootContentByContentEditable(doc);
3705 if (bodyContent && bodyContent->GetPrimaryFrame()) {
3706 newFocus = bodyContent;
3707 }
3708 }
3709 }
3710
3711 // When the mouse is pressed, the default action is to focus the
3712 // target. Look for the nearest enclosing focusable frame.
3713 //
3714 // TODO: Probably this should be moved to Element::PostHandleEvent.
3715 for (; newFocus; newFocus = newFocus->GetFlattenedTreeParent()) {
3716 if (!newFocus->IsElement()) {
3717 continue;
3718 }
3719
3720 nsIFrame* frame = newFocus->GetPrimaryFrame();
3721 if (!frame) {
3722 continue;
3723 }
3724
3725 // If the mousedown happened inside a popup, don't try to set focus on
3726 // one of its containing elements
3727 if (frame->IsMenuPopupFrame()) {
3728 newFocus = nullptr;
3729 break;
3730 }
3731
3732 auto flags = IsFocusableFlags::WithMouse;
3733 if (frame->IsFocusable(flags)) {
3734 break;
3735 }
3736
3737 if (ShadowRoot* root = newFocus->GetShadowRoot()) {
3738 if (root->DelegatesFocus()) {
3739 if (Element* firstFocusable = root->GetFocusDelegate(flags)) {
3740 newFocus = firstFocusable;
3741 break;
3742 }
3743 }
3744 }
3745 }
3746
3747 MOZ_ASSERT_IF(newFocus, newFocus->IsElement())do { if (newFocus) { do { static_assert( mozilla::detail::AssertionConditionType
<decltype(newFocus->IsElement())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(newFocus->IsElement()))),
0))) { do { } while (false); MOZ_ReportAssertionFailure("newFocus->IsElement()"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 3747); AnnotateMozCrashReason("MOZ_ASSERT" "(" "newFocus->IsElement()"
")"); do { *((volatile int*)__null) = 3747; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false)
;
3748
3749 if (RefPtr<nsFocusManager> fm = nsFocusManager::GetFocusManager()) {
3750 // if something was found to focus, focus it. Otherwise, if the
3751 // element that was clicked doesn't have -moz-user-focus: ignore,
3752 // clear the existing focus. For -moz-user-focus: ignore, the focus
3753 // is just left as is.
3754 // Another effect of mouse clicking, handled in Selection, is that
3755 // it should update the caret position to where the mouse was
3756 // clicked. Because the focus is cleared when clicking on a
3757 // non-focusable node, the next press of the tab key will cause
3758 // focus to be shifted from the caret position instead of the root.
3759 if (newFocus) {
3760 // use the mouse flag and the noscroll flag so that the content
3761 // doesn't unexpectedly scroll when clicking an element that is
3762 // only half visible
3763 uint32_t flags =
3764 nsIFocusManager::FLAG_BYMOUSE | nsIFocusManager::FLAG_NOSCROLL;
3765 // If this was a touch-generated event, pass that information:
3766 if (mouseEvent->mInputSource ==
3767 MouseEvent_Binding::MOZ_SOURCE_TOUCH) {
3768 flags |= nsIFocusManager::FLAG_BYTOUCH;
3769 }
3770 fm->SetFocus(MOZ_KnownLive(newFocus->AsElement())(newFocus->AsElement()), flags);
3771 } else if (!suppressBlur) {
3772 // clear the focus within the frame and then set it as the
3773 // focused frame
3774 EnsureDocument(mPresContext);
3775 if (mDocument) {
3776 nsCOMPtr<nsPIDOMWindowOuter> outerWindow = mDocument->GetWindow();
3777#ifdef XP_MACOSX
3778 if (!activeContent || !activeContent->IsXULElement())
3779#endif
3780 fm->ClearFocus(outerWindow);
3781 // Prevent switch frame if we're already not in the foreground tab
3782 // and we're in a content process.
3783 // TODO: If we were inactive frame in this tab, and now in
3784 // background tab, we shouldn't make the tab foreground, but
3785 // we should set focus to clicked document in the background
3786 // tab. However, nsFocusManager does not have proper method
3787 // for doing this. Therefore, we should skip setting focus
3788 // to clicked document for now.
3789 if (XRE_IsParentProcess() || IsInActiveTab(mDocument)) {
3790 fm->SetFocusedWindow(outerWindow);
3791 }
3792 }
3793 }
3794 }
3795
3796 // The rest is left button-specific.
3797 if (mouseEvent->mButton != MouseButton::ePrimary) {
3798 break;
3799 }
3800
3801 // The nearest enclosing element goes into the :active state. If we're
3802 // not an element (so we're text or something) we need to obtain
3803 // our parent element and put it into :active instead.
3804 if (activeContent && !activeContent->IsElement()) {
3805 if (nsIContent* par = activeContent->GetFlattenedTreeParent()) {
3806 activeContent = par;
3807 }
3808 }
3809 } else {
3810 // if we're here, the event handler returned false, so stop
3811 // any of our own processing of a drag. Workaround for bug 43258.
3812 StopTrackingDragGesture(true);
3813 }
3814 // XXX Why do we always set this is active? Active window may be changed
3815 // by a mousedown event listener.
3816 if (NeedsActiveContentChange(mouseEvent)) {
3817 SetActiveManager(this, activeContent);
3818 }
3819 } break;
3820 case ePointerCancel:
3821 case ePointerUp: {
3822 WidgetPointerEvent* pointerEvent = aEvent->AsPointerEvent();
3823 MOZ_ASSERT(pointerEvent)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(pointerEvent)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(pointerEvent))), 0))) { do {
} while (false); MOZ_ReportAssertionFailure("pointerEvent", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 3823); AnnotateMozCrashReason("MOZ_ASSERT" "(" "pointerEvent"
")"); do { *((volatile int*)__null) = 3823; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
3824 // Implicitly releasing capture for given pointer. ePointerLostCapture
3825 // should be send after ePointerUp or ePointerCancel.
3826 PointerEventHandler::ImplicitlyReleasePointerCapture(pointerEvent);
3827 PointerEventHandler::UpdateActivePointerState(pointerEvent);
3828
3829 if (pointerEvent->mMessage == ePointerCancel ||
3830 pointerEvent->mInputSource == MouseEvent_Binding::MOZ_SOURCE_TOUCH) {
3831 // After pointercancel, pointer becomes invalid so we can remove
3832 // relevant helper from table. Regarding pointerup with non-hoverable
3833 // device, the pointer also becomes invalid. Hoverable (mouse/pen)
3834 // pointers are valid all the time (not only between down/up).
3835 GenerateMouseEnterExit(pointerEvent);
3836 mPointersEnterLeaveHelper.Remove(pointerEvent->pointerId);
3837 }
3838 break;
3839 }
3840 case eMouseUp: {
3841 // We can unconditionally stop capturing because
3842 // we should never be capturing when the mouse button is up
3843 PresShell::ReleaseCapturingContent();
3844
3845 WidgetMouseEvent* mouseUpEvent = aEvent->AsMouseEvent();
3846 if (NeedsActiveContentChange(mouseUpEvent)) {
3847 ClearGlobalActiveContent(this);
3848 }
3849 if (mouseUpEvent && EventCausesClickEvents(*mouseUpEvent)) {
3850 // Make sure to dispatch the click even if there is no frame for
3851 // the current target element. This is required for Web compatibility.
3852 RefPtr<EventStateManager> esm =
3853 ESMFromContentOrThis(aOverrideClickTarget);
3854 ret =
3855 esm->PostHandleMouseUp(mouseUpEvent, aStatus, aOverrideClickTarget);
3856 }
3857
3858 if (PresShell* presShell = presContext->GetPresShell()) {
3859 RefPtr<nsFrameSelection> frameSelection = presShell->FrameSelection();
3860 frameSelection->SetDragState(false);
3861 }
3862 } break;
3863 case eWheelOperationEnd: {
3864 MOZ_ASSERT(aEvent->IsTrusted())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aEvent->IsTrusted())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aEvent->IsTrusted()))), 0
))) { do { } while (false); MOZ_ReportAssertionFailure("aEvent->IsTrusted()"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 3864); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aEvent->IsTrusted()"
")"); do { *((volatile int*)__null) = 3864; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
3865 ScrollbarsForWheel::MayInactivate();
3866 WidgetWheelEvent* wheelEvent = aEvent->AsWheelEvent();
3867 nsIScrollableFrame* scrollTarget =
3868 do_QueryFrame(ComputeScrollTargetAndMayAdjustWheelEvent(
3869 mCurrentTarget, wheelEvent,
3870 COMPUTE_DEFAULT_ACTION_TARGET_WITH_AUTO_DIR));
3871 // If the wheel event was handled by APZ, APZ will perform the scroll
3872 // snap.
3873 if (scrollTarget && !WheelTransaction::HandledByApz()) {
3874 scrollTarget->ScrollSnap();
3875 }
3876 } break;
3877 case eWheel:
3878 case eWheelOperationStart: {
3879 MOZ_ASSERT(aEvent->IsTrusted())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aEvent->IsTrusted())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aEvent->IsTrusted()))), 0
))) { do { } while (false); MOZ_ReportAssertionFailure("aEvent->IsTrusted()"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 3879); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aEvent->IsTrusted()"
")"); do { *((volatile int*)__null) = 3879; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
3880
3881 if (*aStatus == nsEventStatus_eConsumeNoDefault) {
3882 ScrollbarsForWheel::Inactivate();
3883 break;
3884 }
3885
3886 WidgetWheelEvent* wheelEvent = aEvent->AsWheelEvent();
3887 MOZ_ASSERT(wheelEvent)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(wheelEvent)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(wheelEvent))), 0))) { do { }
while (false); MOZ_ReportAssertionFailure("wheelEvent", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 3887); AnnotateMozCrashReason("MOZ_ASSERT" "(" "wheelEvent"
")"); do { *((volatile int*)__null) = 3887; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
3888
3889 // When APZ is enabled, the actual scroll animation might be handled by
3890 // the compositor.
3891 WheelPrefs::Action action =
3892 wheelEvent->mFlags.mHandledByAPZ
3893 ? WheelPrefs::ACTION_NONE
3894 : WheelPrefs::GetInstance()->ComputeActionFor(wheelEvent);
3895
3896 WheelDeltaAdjustmentStrategy strategy =
3897 GetWheelDeltaAdjustmentStrategy(*wheelEvent);
3898 // Adjust the delta values of the wheel event if the current default
3899 // action is to horizontalize scrolling. I.e., deltaY values are set to
3900 // deltaX and deltaY and deltaZ values are set to 0.
3901 // If horizontalized, the delta values will be restored and its overflow
3902 // deltaX will become 0 when the WheelDeltaHorizontalizer instance is
3903 // being destroyed.
3904 WheelDeltaHorizontalizer horizontalizer(*wheelEvent);
3905 if (WheelDeltaAdjustmentStrategy::eHorizontalize == strategy) {
3906 horizontalizer.Horizontalize();
3907 }
3908
3909 // Since ComputeScrollTargetAndMayAdjustWheelEvent() may adjust the delta
3910 // if the event is auto-dir. So we use |ESMAutoDirWheelDeltaRestorer|
3911 // here.
3912 // An instance of |ESMAutoDirWheelDeltaRestorer| is used to monitor
3913 // auto-dir adjustment which may happen during its lifetime. If the delta
3914 // values is adjusted during its lifetime, the instance will restore the
3915 // adjusted delta when it's being destrcuted.
3916 ESMAutoDirWheelDeltaRestorer restorer(*wheelEvent);
3917 nsIFrame* frameToScroll = ComputeScrollTargetAndMayAdjustWheelEvent(
3918 mCurrentTarget, wheelEvent,
3919 COMPUTE_DEFAULT_ACTION_TARGET_WITH_AUTO_DIR);
3920
3921 switch (action) {
3922 case WheelPrefs::ACTION_SCROLL:
3923 case WheelPrefs::ACTION_HORIZONTALIZED_SCROLL: {
3924 // For scrolling of default action, we should honor the mouse wheel
3925 // transaction.
3926
3927 ScrollbarsForWheel::PrepareToScrollText(this, mCurrentTarget,
3928 wheelEvent);
3929
3930 if (aEvent->mMessage != eWheel ||
3931 (!wheelEvent->mDeltaX && !wheelEvent->mDeltaY)) {
3932 break;
3933 }
3934
3935 nsIScrollableFrame* scrollTarget = do_QueryFrame(frameToScroll);
3936 ScrollbarsForWheel::SetActiveScrollTarget(scrollTarget);
3937
3938 nsIFrame* rootScrollFrame =
3939 !mCurrentTarget
3940 ? nullptr
3941 : mCurrentTarget->PresShell()->GetRootScrollFrame();
3942 nsIScrollableFrame* rootScrollableFrame = nullptr;
3943 if (rootScrollFrame) {
3944 rootScrollableFrame = do_QueryFrame(rootScrollFrame);
3945 }
3946 if (!scrollTarget || scrollTarget == rootScrollableFrame) {
3947 wheelEvent->mViewPortIsOverscrolled = true;
3948 }
3949 wheelEvent->mOverflowDeltaX = wheelEvent->mDeltaX;
3950 wheelEvent->mOverflowDeltaY = wheelEvent->mDeltaY;
3951 WheelPrefs::GetInstance()->CancelApplyingUserPrefsFromOverflowDelta(
3952 wheelEvent);
3953 if (scrollTarget) {
3954 DoScrollText(scrollTarget, wheelEvent);
3955 } else {
3956 WheelTransaction::EndTransaction();
3957 ScrollbarsForWheel::Inactivate();
3958 }
3959 break;
3960 }
3961 case WheelPrefs::ACTION_HISTORY: {
3962 // If this event doesn't cause eLegacyMouseLineOrPageScroll event or
3963 // the direction is oblique, don't perform history back/forward.
3964 int32_t intDelta = wheelEvent->GetPreferredIntDelta();
3965 if (!intDelta) {
3966 break;
3967 }
3968 DoScrollHistory(intDelta);
3969 break;
3970 }
3971 case WheelPrefs::ACTION_ZOOM: {
3972 // If this event doesn't cause eLegacyMouseLineOrPageScroll event or
3973 // the direction is oblique, don't perform zoom in/out.
3974 int32_t intDelta = wheelEvent->GetPreferredIntDelta();
3975 if (!intDelta) {
3976 break;
3977 }
3978 DoScrollZoom(mCurrentTarget, intDelta);
3979 break;
3980 }
3981 case WheelPrefs::ACTION_NONE:
3982 default:
3983 bool allDeltaOverflown = false;
3984 if (StaticPrefs::dom_event_wheel_event_groups_enabled() &&
3985 (wheelEvent->mDeltaX != 0.0 || wheelEvent->mDeltaY != 0.0)) {
3986 if (frameToScroll) {
3987 WheelTransaction::WillHandleDefaultAction(
3988 wheelEvent, frameToScroll, mCurrentTarget);
3989 } else {
3990 WheelTransaction::EndTransaction();
3991 }
3992 }
3993 if (wheelEvent->mFlags.mHandledByAPZ) {
3994 if (wheelEvent->mCanTriggerSwipe) {
3995 // For events that can trigger swipes, APZ needs to know whether
3996 // scrolling is possible in the requested direction. It does this
3997 // by looking at the scroll overflow values on mCanTriggerSwipe
3998 // events after they have been processed.
3999 allDeltaOverflown = !ComputeScrollTarget(
4000 mCurrentTarget, wheelEvent, COMPUTE_DEFAULT_ACTION_TARGET);
4001 }
4002 } else {
4003 // The event was processed neither by APZ nor by us, so all of the
4004 // delta values must be overflown delta values.
4005 allDeltaOverflown = true;
4006 }
4007
4008 if (!allDeltaOverflown) {
4009 break;
4010 }
4011 wheelEvent->mOverflowDeltaX = wheelEvent->mDeltaX;
4012 wheelEvent->mOverflowDeltaY = wheelEvent->mDeltaY;
4013 WheelPrefs::GetInstance()->CancelApplyingUserPrefsFromOverflowDelta(
4014 wheelEvent);
4015 wheelEvent->mViewPortIsOverscrolled = true;
4016 break;
4017 }
4018 *aStatus = nsEventStatus_eConsumeNoDefault;
4019 } break;
4020
4021 case eGestureNotify: {
4022 if (nsEventStatus_eConsumeNoDefault != *aStatus) {
4023 DecideGestureEvent(aEvent->AsGestureNotifyEvent(), mCurrentTarget);
4024 }
4025 } break;
4026
4027 case eDragEnter:
4028 case eDragOver: {
4029 NS_ASSERTION(aEvent->mClass == eDragEventClass, "Expected a drag event")do { if (!(aEvent->mClass == eDragEventClass)) { NS_DebugBreak
(NS_DEBUG_ASSERTION, "Expected a drag event", "aEvent->mClass == eDragEventClass"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 4029); MOZ_PretendNoReturn(); } } while (0)
;
4030
4031 // Check if the drag is occurring inside a scrollable area. If so, scroll
4032 // the area when the mouse is near the edges.
4033 if (mCurrentTarget && aEvent->mMessage == eDragOver) {
4034 nsIFrame* checkFrame = mCurrentTarget;
4035 while (checkFrame) {
4036 nsIScrollableFrame* scrollFrame = do_QueryFrame(checkFrame);
4037 // Break out so only the innermost scrollframe is scrolled.
4038 if (scrollFrame && scrollFrame->DragScroll(aEvent)) {
4039 break;
4040 }
4041 checkFrame = checkFrame->GetParent();
4042 }
4043 }
4044
4045 nsCOMPtr<nsIDragSession> dragSession = nsContentUtils::GetDragSession();
4046 if (!dragSession) break;
4047
4048 // Reset the flag.
4049 dragSession->SetOnlyChromeDrop(false);
4050 if (mPresContext) {
4051 EnsureDocument(mPresContext);
4052 }
4053 bool isChromeDoc = nsContentUtils::IsChromeDoc(mDocument);
4054
4055 // the initial dataTransfer is the one from the dragstart event that
4056 // was set on the dragSession when the drag began.
4057 RefPtr<DataTransfer> dataTransfer;
4058 RefPtr<DataTransfer> initialDataTransfer = dragSession->GetDataTransfer();
4059
4060 WidgetDragEvent* dragEvent = aEvent->AsDragEvent();
4061
4062 // collect any changes to moz cursor settings stored in the event's
4063 // data transfer.
4064 UpdateDragDataTransfer(dragEvent);
4065
4066 // cancelling a dragenter or dragover event means that a drop should be
4067 // allowed, so update the dropEffect and the canDrop state to indicate
4068 // that a drag is allowed. If the event isn't cancelled, a drop won't be
4069 // allowed. Essentially, to allow a drop somewhere, specify the effects
4070 // using the effectAllowed and dropEffect properties in a dragenter or
4071 // dragover event and cancel the event. To not allow a drop somewhere,
4072 // don't cancel the event or set the effectAllowed or dropEffect to
4073 // "none". This way, if the event is just ignored, no drop will be
4074 // allowed.
4075 uint32_t dropEffect = nsIDragService::DRAGDROP_ACTION_NONE;
4076 uint32_t action = nsIDragService::DRAGDROP_ACTION_NONE;
4077 if (nsEventStatus_eConsumeNoDefault == *aStatus) {
4078 // If the event has initialized its mDataTransfer, use it.
4079 // Or the event has not been initialized its mDataTransfer, but
4080 // it's set before dispatch because of synthesized, but without
4081 // testing session (e.g., emulating drag from another app), use it
4082 // coming from outside.
4083 // XXX Perhaps, for the latter case, we need new API because we don't
4084 // have a chance to initialize allowed effects of the session.
4085 if (dragEvent->mDataTransfer) {
4086 // get the dataTransfer and the dropEffect that was set on it
4087 dataTransfer = dragEvent->mDataTransfer;
4088 dropEffect = dataTransfer->DropEffectInt();
4089 } else {
4090 // if dragEvent->mDataTransfer is null, it means that no attempt was
4091 // made to access the dataTransfer during the event, yet the event
4092 // was cancelled. Instead, use the initial data transfer available
4093 // from the drag session. The drop effect would not have been
4094 // initialized (which is done in DragEvent::GetDataTransfer),
4095 // so set it from the drag action. We'll still want to filter it
4096 // based on the effectAllowed below.
4097 dataTransfer = initialDataTransfer;
4098
4099 dragSession->GetDragAction(&action);
4100
4101 // filter the drop effect based on the action. Use UNINITIALIZED as
4102 // any effect is allowed.
4103 dropEffect = nsContentUtils::FilterDropEffect(
4104 action, nsIDragService::DRAGDROP_ACTION_UNINITIALIZED);
4105 }
4106
4107 // At this point, if the dataTransfer is null, it means that the
4108 // drag was originally started by directly calling the drag service.
4109 // Just assume that all effects are allowed.
4110 uint32_t effectAllowed = nsIDragService::DRAGDROP_ACTION_UNINITIALIZED;
4111 if (dataTransfer) {
4112 effectAllowed = dataTransfer->EffectAllowedInt();
4113 }
4114
4115 // set the drag action based on the drop effect and effect allowed.
4116 // The drop effect field on the drag transfer object specifies the
4117 // desired current drop effect. However, it cannot be used if the
4118 // effectAllowed state doesn't include that type of action. If the
4119 // dropEffect is "none", then the action will be 'none' so a drop will
4120 // not be allowed.
4121 if (effectAllowed == nsIDragService::DRAGDROP_ACTION_UNINITIALIZED ||
4122 dropEffect & effectAllowed)
4123 action = dropEffect;
4124
4125 if (action == nsIDragService::DRAGDROP_ACTION_NONE)
4126 dropEffect = nsIDragService::DRAGDROP_ACTION_NONE;
4127
4128 // inform the drag session that a drop is allowed on this node.
4129 dragSession->SetDragAction(action);
4130 dragSession->SetCanDrop(action != nsIDragService::DRAGDROP_ACTION_NONE);
4131
4132 // For now, do this only for dragover.
4133 // XXXsmaug dragenter needs some more work.
4134 if (aEvent->mMessage == eDragOver && !isChromeDoc) {
4135 // Someone has called preventDefault(), check whether is was on
4136 // content or chrome.
4137 dragSession->SetOnlyChromeDrop(
4138 !dragEvent->mDefaultPreventedOnContent);
4139 }
4140 } else if (aEvent->mMessage == eDragOver && !isChromeDoc) {
4141 // No one called preventDefault(), so handle drop only in chrome.
4142 dragSession->SetOnlyChromeDrop(true);
4143 }
4144 if (ContentChild* child = ContentChild::GetSingleton()) {
4145 child->SendUpdateDropEffect(action, dropEffect);
4146 }
4147 if (aEvent->HasBeenPostedToRemoteProcess()) {
4148 dragSession->SetCanDrop(true);
4149 } else if (initialDataTransfer) {
4150 // Now set the drop effect in the initial dataTransfer. This ensures
4151 // that we can get the desired drop effect in the drop event. For events
4152 // dispatched to content, the content process will take care of setting
4153 // this.
4154 initialDataTransfer->SetDropEffectInt(dropEffect);
4155 }
4156 } break;
4157
4158 case eDrop: {
4159 if (aEvent->mFlags.mIsSynthesizedForTests) {
4160 if (nsCOMPtr<nsIDragSession> dragSession =
4161 nsContentUtils::GetDragSession()) {
4162 MOZ_ASSERT(dragSession->IsSynthesizedForTests())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(dragSession->IsSynthesizedForTests())>::isValid
, "invalid assertion condition"); if ((__builtin_expect(!!(!(
!!(dragSession->IsSynthesizedForTests()))), 0))) { do { } while
(false); MOZ_ReportAssertionFailure("dragSession->IsSynthesizedForTests()"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 4162); AnnotateMozCrashReason("MOZ_ASSERT" "(" "dragSession->IsSynthesizedForTests()"
")"); do { *((volatile int*)__null) = 4162; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
4163 RefPtr<WindowContext> sourceWC;
4164 DebugOnly<nsresult> rvIgnored =
4165 dragSession->GetSourceWindowContext(getter_AddRefs(sourceWC));
4166 NS_WARNING_ASSERTION(do { if (!(((bool)(__builtin_expect(!!(!NS_FAILED_impl(rvIgnored
)), 1))))) { NS_DebugBreak(NS_DEBUG_WARNING, "nsIDragSession::GetSourceDocument() failed, but ignored"
, "NS_SUCCEEDED(rvIgnored)", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 4168); } } while (false)
4167 NS_SUCCEEDED(rvIgnored),do { if (!(((bool)(__builtin_expect(!!(!NS_FAILED_impl(rvIgnored
)), 1))))) { NS_DebugBreak(NS_DEBUG_WARNING, "nsIDragSession::GetSourceDocument() failed, but ignored"
, "NS_SUCCEEDED(rvIgnored)", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 4168); } } while (false)
4168 "nsIDragSession::GetSourceDocument() failed, but ignored")do { if (!(((bool)(__builtin_expect(!!(!NS_FAILED_impl(rvIgnored
)), 1))))) { NS_DebugBreak(NS_DEBUG_WARNING, "nsIDragSession::GetSourceDocument() failed, but ignored"
, "NS_SUCCEEDED(rvIgnored)", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 4168); } } while (false)
;
4169 // If the drag source hasn't been initialized, i.e., dragstart was
4170 // consumed by the test, the test needs to dispatch "dragend" event
4171 // instead of the drag session. Therefore, it does not make sense
4172 // to set drag end point in such case (you hit assersion if you do
4173 // it).
4174 if (sourceWC) {
4175 CSSIntPoint dropPointInScreen =
4176 Event::GetScreenCoords(aPresContext, aEvent, aEvent->mRefPoint)
4177 .extract();
4178 dragSession->SetDragEndPointForTests(dropPointInScreen.x,
4179 dropPointInScreen.y);
4180 }
4181 }
4182 }
4183 sLastDragOverFrame = nullptr;
4184 ClearGlobalActiveContent(this);
4185 break;
4186 }
4187 case eDragExit:
4188 // make sure to fire the enter and exit_synth events after the
4189 // eDragExit event, otherwise we'll clean up too early
4190 GenerateDragDropEnterExit(presContext, aEvent->AsDragEvent());
4191 if (ContentChild* child = ContentChild::GetSingleton()) {
4192 // SendUpdateDropEffect to prevent nsIDragService from waiting for
4193 // response of forwarded dragexit event.
4194 child->SendUpdateDropEffect(nsIDragService::DRAGDROP_ACTION_NONE,
4195 nsIDragService::DRAGDROP_ACTION_NONE);
4196 }
4197 break;
4198
4199 case eKeyUp:
4200 // If space key is released, we need to inactivate the element which was
4201 // activated by preceding space key down.
4202 // XXX Currently, we don't store the reason of activation. Therefore,
4203 // this may cancel what is activated by a mousedown, but it must not
4204 // cause actual problem in web apps in the wild since it must be
4205 // rare case that users release space key during a mouse click/drag.
4206 if (aEvent->AsKeyboardEvent()->ShouldWorkAsSpaceKey()) {
4207 ClearGlobalActiveContent(this);
4208 }
4209 break;
4210
4211 case eKeyPress: {
4212 WidgetKeyboardEvent* keyEvent = aEvent->AsKeyboardEvent();
4213 PostHandleKeyboardEvent(keyEvent, mCurrentTarget, *aStatus);
4214 } break;
4215
4216 case eMouseEnterIntoWidget:
4217 if (mCurrentTarget) {
4218 nsCOMPtr<nsIContent> targetContent;
4219 mCurrentTarget->GetContentForEvent(aEvent,
4220 getter_AddRefs(targetContent));
4221 SetContentState(targetContent, ElementState::HOVER);
4222 }
4223 break;
4224
4225 case eMouseExitFromWidget:
4226 PointerEventHandler::UpdateActivePointerState(aEvent->AsMouseEvent());
4227 break;
4228
4229#ifdef XP_MACOSX
4230 case eMouseActivate:
4231 if (mCurrentTarget) {
4232 nsCOMPtr<nsIContent> targetContent;
4233 mCurrentTarget->GetContentForEvent(aEvent,
4234 getter_AddRefs(targetContent));
4235 if (!NodeAllowsClickThrough(targetContent)) {
4236 *aStatus = nsEventStatus_eConsumeNoDefault;
4237 }
4238 }
4239 break;
4240#endif
4241
4242 default:
4243 break;
4244 }
4245
4246 // Reset target frame to null to avoid mistargeting after reentrant event
4247 mCurrentTarget = nullptr;
4248 mCurrentTargetContent = nullptr;
4249
4250 return ret;
4251}
4252
4253BrowserParent* EventStateManager::GetCrossProcessTarget() {
4254 return IMEStateManager::GetActiveBrowserParent();
4255}
4256
4257bool EventStateManager::IsTargetCrossProcess(WidgetGUIEvent* aEvent) {
4258 // Check to see if there is a focused, editable content in chrome,
4259 // in that case, do not forward IME events to content
4260 Element* focusedElement = GetFocusedElement();
4261 if (focusedElement && focusedElement->IsEditable()) {
4262 return false;
4263 }
4264 return IMEStateManager::GetActiveBrowserParent() != nullptr;
4265}
4266
4267void EventStateManager::NotifyDestroyPresContext(nsPresContext* aPresContext) {
4268 RefPtr<nsPresContext> presContext = aPresContext;
4269 if (presContext) {
4270 IMEStateManager::OnDestroyPresContext(*presContext);
4271 }
4272
4273 // Bug 70855: Presentation is going away, possibly for a reframe.
4274 // Reset the hover state so that if we're recreating the presentation,
4275 // we won't have the old hover state still set in the new presentation,
4276 // as if the new presentation is resized, a new element may be hovered.
4277 ResetHoverState();
4278
4279 mPointersEnterLeaveHelper.Clear();
4280 PointerEventHandler::NotifyDestroyPresContext(presContext);
4281}
4282
4283void EventStateManager::ResetHoverState() {
4284 if (mHoverContent) {
4285 SetContentState(nullptr, ElementState::HOVER);
4286 }
4287}
4288
4289void EventStateManager::SetPresContext(nsPresContext* aPresContext) {
4290 mPresContext = aPresContext;
4291}
4292
4293void EventStateManager::ClearFrameRefs(nsIFrame* aFrame) {
4294 if (aFrame && aFrame == mCurrentTarget) {
4295 mCurrentTargetContent = aFrame->GetContent();
4296 }
4297}
4298
4299struct CursorImage {
4300 gfx::IntPoint mHotspot;
4301 nsCOMPtr<imgIContainer> mContainer;
4302 ImageResolution mResolution;
4303 bool mEarlierCursorLoading = false;
4304};
4305
4306// Given the event that we're processing, and the computed cursor and hotspot,
4307// determine whether the custom CSS cursor should be blocked (that is, not
4308// honored).
4309//
4310// We will not honor it all of the following are true:
4311//
4312// * the size of the custom cursor is bigger than layout.cursor.block.max-size.
4313// * the bounds of the cursor would end up outside of the viewport of the
4314// top-level content document.
4315//
4316// This is done in order to prevent hijacking the cursor, see bug 1445844 and
4317// co.
4318static bool ShouldBlockCustomCursor(nsPresContext* aPresContext,
4319 WidgetEvent* aEvent,
4320 const CursorImage& aCursor) {
4321 int32_t width = 0;
4322 int32_t height = 0;
4323 aCursor.mContainer->GetWidth(&width);
4324 aCursor.mContainer->GetHeight(&height);
4325 aCursor.mResolution.ApplyTo(width, height);
4326
4327 int32_t maxSize = StaticPrefs::layout_cursor_block_max_size();
4328
4329 if (width <= maxSize && height <= maxSize) {
4330 return false;
4331 }
4332
4333 auto input = DOMIntersectionObserver::ComputeInput(*aPresContext->Document(),
4334 nullptr, nullptr);
4335
4336 if (!input.mRootFrame) {
4337 return false;
4338 }
4339
4340 nsPoint point = nsLayoutUtils::GetEventCoordinatesRelativeTo(
4341 aEvent, RelativeTo{input.mRootFrame});
4342
4343 // The cursor size won't be affected by our full zoom in the parent process,
4344 // so undo that before checking the rect.
4345 float zoom = aPresContext->GetFullZoom();
4346
4347 // Also adjust for accessibility cursor scaling factor.
4348 zoom /= LookAndFeel::GetFloat(LookAndFeel::FloatID::CursorScale, 1.0f);
4349
4350 nsSize size(CSSPixel::ToAppUnits(width / zoom),
4351 CSSPixel::ToAppUnits(height / zoom));
4352 nsPoint hotspot(
4353 CSSPixel::ToAppUnits(ViewAs<CSSPixel>(aCursor.mHotspot.x / zoom)),
4354 CSSPixel::ToAppUnits(ViewAs<CSSPixel>(aCursor.mHotspot.y / zoom)));
4355
4356 const nsRect cursorRect(point - hotspot, size);
4357 auto output = DOMIntersectionObserver::Intersect(input, cursorRect);
4358 return !output.mIntersectionRect ||
4359 !(*output.mIntersectionRect == cursorRect);
4360}
4361
4362static gfx::IntPoint ComputeHotspot(imgIContainer* aContainer,
4363 const Maybe<gfx::Point>& aHotspot) {
4364 MOZ_ASSERT(aContainer)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aContainer)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aContainer))), 0))) { do { }
while (false); MOZ_ReportAssertionFailure("aContainer", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 4364); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aContainer"
")"); do { *((volatile int*)__null) = 4364; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
4365
4366 // css3-ui says to use the CSS-specified hotspot if present,
4367 // otherwise use the intrinsic hotspot, otherwise use the top left
4368 // corner.
4369 if (aHotspot) {
4370 int32_t imgWidth, imgHeight;
4371 aContainer->GetWidth(&imgWidth);
4372 aContainer->GetHeight(&imgHeight);
4373 auto hotspot = gfx::IntPoint::Round(*aHotspot);
4374 return {std::max(std::min(hotspot.x.value, imgWidth - 1), 0),
4375 std::max(std::min(hotspot.y.value, imgHeight - 1), 0)};
4376 }
4377
4378 gfx::IntPoint hotspot;
4379 aContainer->GetHotspotX(&hotspot.x.value);
4380 aContainer->GetHotspotY(&hotspot.y.value);
4381 return hotspot;
4382}
4383
4384static CursorImage ComputeCustomCursor(nsPresContext* aPresContext,
4385 WidgetEvent* aEvent,
4386 const nsIFrame& aFrame,
4387 const nsIFrame::Cursor& aCursor) {
4388 if (aCursor.mAllowCustomCursor == nsIFrame::AllowCustomCursorImage::No) {
4389 return {};
4390 }
4391 const ComputedStyle& style =
4392 aCursor.mStyle ? *aCursor.mStyle : *aFrame.Style();
4393
4394 // If we are falling back because any cursor before us is loading, let the
4395 // consumer know.
4396 bool loading = false;
4397 for (const auto& image : style.StyleUI()->Cursor().images.AsSpan()) {
4398 MOZ_ASSERT(image.image.IsImageRequestType(),do { static_assert( mozilla::detail::AssertionConditionType<
decltype(image.image.IsImageRequestType())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(image.image.IsImageRequestType
()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("image.image.IsImageRequestType()" " (" "Cursor image should only parse url() types"
")", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 4399); AnnotateMozCrashReason("MOZ_ASSERT" "(" "image.image.IsImageRequestType()"
") (" "Cursor image should only parse url() types" ")"); do {
*((volatile int*)__null) = 4399; __attribute__((nomerge)) ::
abort(); } while (false); } } while (false)
4399 "Cursor image should only parse url() types")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(image.image.IsImageRequestType())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(image.image.IsImageRequestType
()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("image.image.IsImageRequestType()" " (" "Cursor image should only parse url() types"
")", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 4399); AnnotateMozCrashReason("MOZ_ASSERT" "(" "image.image.IsImageRequestType()"
") (" "Cursor image should only parse url() types" ")"); do {
*((volatile int*)__null) = 4399; __attribute__((nomerge)) ::
abort(); } while (false); } } while (false)
;
4400 uint32_t status;
4401 imgRequestProxy* req = image.image.GetImageRequest();
4402 if (!req || NS_FAILED(req->GetImageStatus(&status))((bool)(__builtin_expect(!!(NS_FAILED_impl(req->GetImageStatus
(&status))), 0)))
) {
4403 continue;
4404 }
4405 if (!(status & imgIRequest::STATUS_LOAD_COMPLETE)) {
4406 loading = true;
4407 continue;
4408 }
4409 if (status & imgIRequest::STATUS_ERROR) {
4410 continue;
4411 }
4412 nsCOMPtr<imgIContainer> container;
4413 req->GetImage(getter_AddRefs(container));
4414 if (!container) {
4415 continue;
4416 }
4417 StyleImageOrientation orientation =
4418 aFrame.StyleVisibility()->UsedImageOrientation(req);
4419 container = nsLayoutUtils::OrientImage(container, orientation);
4420 Maybe<gfx::Point> specifiedHotspot =
4421 image.has_hotspot ? Some(gfx::Point{image.hotspot_x, image.hotspot_y})
4422 : Nothing();
4423 gfx::IntPoint hotspot = ComputeHotspot(container, specifiedHotspot);
4424 CursorImage result{hotspot, std::move(container),
4425 image.image.GetResolution(style), loading};
4426 if (ShouldBlockCustomCursor(aPresContext, aEvent, result)) {
4427 continue;
4428 }
4429 // This is the one we want!
4430 return result;
4431 }
4432 return {{}, nullptr, {}, loading};
4433}
4434
4435void EventStateManager::UpdateCursor(nsPresContext* aPresContext,
4436 WidgetMouseEvent* aEvent,
4437 nsIFrame* aTargetFrame,
4438 nsEventStatus* aStatus) {
4439 if (aTargetFrame && IsRemoteTarget(aTargetFrame->GetContent())) {
4440 return;
4441 }
4442
4443 auto cursor = StyleCursorKind::Default;
4444 nsCOMPtr<imgIContainer> container;
4445 ImageResolution resolution;
4446 Maybe<gfx::IntPoint> hotspot;
4447
4448 if (mHidingCursorWhileTyping && aEvent->IsReal()) {
4449 // Any non-synthetic mouse event makes us show the cursor again.
4450 mHidingCursorWhileTyping = false;
4451 }
4452
4453 if (mHidingCursorWhileTyping) {
4454 cursor = StyleCursorKind::None;
4455 } else if (mLockCursor != kInvalidCursorKind) {
4456 // If cursor is locked just use the locked one
4457 cursor = mLockCursor;
4458 } else if (aTargetFrame) {
4459 // If not locked, look for correct cursor
4460 nsPoint pt = nsLayoutUtils::GetEventCoordinatesRelativeTo(
4461 aEvent, RelativeTo{aTargetFrame});
4462 const nsIFrame::Cursor framecursor = aTargetFrame->GetCursor(pt);
4463 const CursorImage customCursor =
4464 ComputeCustomCursor(aPresContext, aEvent, *aTargetFrame, framecursor);
4465
4466 // If the current cursor is from the same frame, and it is now
4467 // loading some new image for the cursor, we should wait for a
4468 // while rather than taking its fallback cursor directly.
4469 if (customCursor.mEarlierCursorLoading &&
4470 gLastCursorSourceFrame == aTargetFrame &&
4471 TimeStamp::NowLoRes() - gLastCursorUpdateTime <
4472 TimeDuration::FromMilliseconds(kCursorLoadingTimeout)) {
4473 return;
4474 }
4475 cursor = framecursor.mCursor;
4476 container = std::move(customCursor.mContainer);
4477 resolution = customCursor.mResolution;
4478 hotspot = Some(customCursor.mHotspot);
4479 }
4480
4481 if (aTargetFrame) {
4482 if (cursor == StyleCursorKind::Pointer && IsSelectingLink(aTargetFrame)) {
4483 cursor = aTargetFrame->GetWritingMode().IsVertical()
4484 ? StyleCursorKind::VerticalText
4485 : StyleCursorKind::Text;
4486 }
4487 SetCursor(cursor, container, resolution, hotspot,
4488 aTargetFrame->GetNearestWidget(), false);
4489 gLastCursorSourceFrame = aTargetFrame;
4490 gLastCursorUpdateTime = TimeStamp::NowLoRes();
4491 }
4492
4493 if (mLockCursor != kInvalidCursorKind || StyleCursorKind::Auto != cursor) {
4494 *aStatus = nsEventStatus_eConsumeDoDefault;
4495 }
4496}
4497
4498void EventStateManager::ClearCachedWidgetCursor(nsIFrame* aTargetFrame) {
4499 if (!aTargetFrame) {
4500 return;
4501 }
4502 nsIWidget* aWidget = aTargetFrame->GetNearestWidget();
4503 if (!aWidget) {
4504 return;
4505 }
4506 aWidget->ClearCachedCursor();
4507}
4508
4509void EventStateManager::StartHidingCursorWhileTyping(nsIWidget* aWidget) {
4510 if (mHidingCursorWhileTyping || sCursorSettingManager != this) {
4511 return;
4512 }
4513 mHidingCursorWhileTyping = true;
4514 SetCursor(StyleCursorKind::None, nullptr, {}, {}, aWidget, false);
4515}
4516
4517nsresult EventStateManager::SetCursor(StyleCursorKind aCursor,
4518 imgIContainer* aContainer,
4519 const ImageResolution& aResolution,
4520 const Maybe<gfx::IntPoint>& aHotspot,
4521 nsIWidget* aWidget, bool aLockCursor) {
4522 EnsureDocument(mPresContext);
4523 NS_ENSURE_TRUE(mDocument, NS_ERROR_FAILURE)do { if ((__builtin_expect(!!(!(mDocument)), 0))) { NS_DebugBreak
(NS_DEBUG_WARNING, "NS_ENSURE_TRUE(" "mDocument" ") failed", nullptr
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 4523); return NS_ERROR_FAILURE; } } while (false)
;
4524 sCursorSettingManager = this;
4525
4526 NS_ENSURE_TRUE(aWidget, NS_ERROR_FAILURE)do { if ((__builtin_expect(!!(!(aWidget)), 0))) { NS_DebugBreak
(NS_DEBUG_WARNING, "NS_ENSURE_TRUE(" "aWidget" ") failed", nullptr
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 4526); return NS_ERROR_FAILURE; } } while (false)
;
4527 if (aLockCursor) {
4528 if (StyleCursorKind::Auto != aCursor) {
4529 mLockCursor = aCursor;
4530 } else {
4531 // If cursor style is set to auto we unlock the cursor again.
4532 mLockCursor = kInvalidCursorKind;
4533 }
4534 }
4535 nsCursor c;
4536 switch (aCursor) {
4537 case StyleCursorKind::Auto:
4538 case StyleCursorKind::Default:
4539 c = eCursor_standard;
4540 break;
4541 case StyleCursorKind::Pointer:
4542 c = eCursor_hyperlink;
4543 break;
4544 case StyleCursorKind::Crosshair:
4545 c = eCursor_crosshair;
4546 break;
4547 case StyleCursorKind::Move:
4548 c = eCursor_move;
4549 break;
4550 case StyleCursorKind::Text:
4551 c = eCursor_select;
4552 break;
4553 case StyleCursorKind::Wait:
4554 c = eCursor_wait;
4555 break;
4556 case StyleCursorKind::Help:
4557 c = eCursor_help;
4558 break;
4559 case StyleCursorKind::NResize:
4560 c = eCursor_n_resize;
4561 break;
4562 case StyleCursorKind::SResize:
4563 c = eCursor_s_resize;
4564 break;
4565 case StyleCursorKind::WResize:
4566 c = eCursor_w_resize;
4567 break;
4568 case StyleCursorKind::EResize:
4569 c = eCursor_e_resize;
4570 break;
4571 case StyleCursorKind::NwResize:
4572 c = eCursor_nw_resize;
4573 break;
4574 case StyleCursorKind::SeResize:
4575 c = eCursor_se_resize;
4576 break;
4577 case StyleCursorKind::NeResize:
4578 c = eCursor_ne_resize;
4579 break;
4580 case StyleCursorKind::SwResize:
4581 c = eCursor_sw_resize;
4582 break;
4583 case StyleCursorKind::Copy: // CSS3
4584 c = eCursor_copy;
4585 break;
4586 case StyleCursorKind::Alias:
4587 c = eCursor_alias;
4588 break;
4589 case StyleCursorKind::ContextMenu:
4590 c = eCursor_context_menu;
4591 break;
4592 case StyleCursorKind::Cell:
4593 c = eCursor_cell;
4594 break;
4595 case StyleCursorKind::Grab:
4596 c = eCursor_grab;
4597 break;
4598 case StyleCursorKind::Grabbing:
4599 c = eCursor_grabbing;
4600 break;
4601 case StyleCursorKind::Progress:
4602 c = eCursor_spinning;
4603 break;
4604 case StyleCursorKind::ZoomIn:
4605 c = eCursor_zoom_in;
4606 break;
4607 case StyleCursorKind::ZoomOut:
4608 c = eCursor_zoom_out;
4609 break;
4610 case StyleCursorKind::NotAllowed:
4611 c = eCursor_not_allowed;
4612 break;
4613 case StyleCursorKind::ColResize:
4614 c = eCursor_col_resize;
4615 break;
4616 case StyleCursorKind::RowResize:
4617 c = eCursor_row_resize;
4618 break;
4619 case StyleCursorKind::NoDrop:
4620 c = eCursor_no_drop;
4621 break;
4622 case StyleCursorKind::VerticalText:
4623 c = eCursor_vertical_text;
4624 break;
4625 case StyleCursorKind::AllScroll:
4626 c = eCursor_all_scroll;
4627 break;
4628 case StyleCursorKind::NeswResize:
4629 c = eCursor_nesw_resize;
4630 break;
4631 case StyleCursorKind::NwseResize:
4632 c = eCursor_nwse_resize;
4633 break;
4634 case StyleCursorKind::NsResize:
4635 c = eCursor_ns_resize;
4636 break;
4637 case StyleCursorKind::EwResize:
4638 c = eCursor_ew_resize;
4639 break;
4640 case StyleCursorKind::None:
4641 c = eCursor_none;
4642 break;
4643 default:
4644 MOZ_ASSERT_UNREACHABLE("Unknown cursor kind")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(false)>::isValid, "invalid assertion condition");
if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("false" " (" "MOZ_ASSERT_UNREACHABLE: "
"Unknown cursor kind" ")", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 4644); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") ("
"MOZ_ASSERT_UNREACHABLE: " "Unknown cursor kind" ")"); do { *
((volatile int*)__null) = 4644; __attribute__((nomerge)) ::abort
(); } while (false); } } while (false)
;
4645 c = eCursor_standard;
4646 break;
4647 }
4648
4649 uint32_t x = aHotspot ? aHotspot->x.value : 0;
4650 uint32_t y = aHotspot ? aHotspot->y.value : 0;
4651 aWidget->SetCursor(nsIWidget::Cursor{c, aContainer, x, y, aResolution});
4652 return NS_OK;
4653}
4654
4655class MOZ_STACK_CLASS ESMEventCB : public EventDispatchingCallback {
4656 public:
4657 explicit ESMEventCB(nsIContent* aTarget) : mTarget(aTarget) {}
4658
4659 MOZ_CAN_RUN_SCRIPT
4660 void HandleEvent(EventChainPostVisitor& aVisitor) override {
4661 if (aVisitor.mPresContext) {
4662 nsIFrame* frame = aVisitor.mPresContext->GetPrimaryFrameFor(mTarget);
4663 if (frame) {
4664 frame->HandleEvent(aVisitor.mPresContext, aVisitor.mEvent->AsGUIEvent(),
4665 &aVisitor.mEventStatus);
4666 }
4667 }
4668 }
4669
4670 nsCOMPtr<nsIContent> mTarget;
4671};
4672
4673static UniquePtr<WidgetMouseEvent> CreateMouseOrPointerWidgetEvent(
4674 WidgetMouseEvent* aMouseEvent, EventMessage aMessage,
4675 EventTarget* aRelatedTarget) {
4676 // This method does not support creating a mouse/pointer button change event
4677 // because of no data about the changing state.
4678 MOZ_ASSERT(aMessage != eMouseDown)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aMessage != eMouseDown)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aMessage != eMouseDown))), 0
))) { do { } while (false); MOZ_ReportAssertionFailure("aMessage != eMouseDown"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 4678); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aMessage != eMouseDown"
")"); do { *((volatile int*)__null) = 4678; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
4679 MOZ_ASSERT(aMessage != eMouseUp)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aMessage != eMouseUp)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aMessage != eMouseUp))), 0))
) { do { } while (false); MOZ_ReportAssertionFailure("aMessage != eMouseUp"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 4679); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aMessage != eMouseUp"
")"); do { *((volatile int*)__null) = 4679; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
4680 MOZ_ASSERT(aMessage != ePointerDown)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aMessage != ePointerDown)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aMessage != ePointerDown))),
0))) { do { } while (false); MOZ_ReportAssertionFailure("aMessage != ePointerDown"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 4680); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aMessage != ePointerDown"
")"); do { *((volatile int*)__null) = 4680; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
4681 MOZ_ASSERT(aMessage != ePointerUp)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aMessage != ePointerUp)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aMessage != ePointerUp))), 0
))) { do { } while (false); MOZ_ReportAssertionFailure("aMessage != ePointerUp"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 4681); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aMessage != ePointerUp"
")"); do { *((volatile int*)__null) = 4681; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
4682 // This method is currently designed to create the following events.
4683 MOZ_ASSERT(aMessage == eMouseOver || aMessage == eMouseEnter ||do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aMessage == eMouseOver || aMessage == eMouseEnter ||
aMessage == eMouseOut || aMessage == eMouseLeave || aMessage
== ePointerOver || aMessage == ePointerEnter || aMessage == ePointerOut
|| aMessage == ePointerLeave || aMessage == eMouseEnterIntoWidget
|| aMessage == eMouseExitFromWidget)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aMessage == eMouseOver || aMessage
== eMouseEnter || aMessage == eMouseOut || aMessage == eMouseLeave
|| aMessage == ePointerOver || aMessage == ePointerEnter || aMessage
== ePointerOut || aMessage == ePointerLeave || aMessage == eMouseEnterIntoWidget
|| aMessage == eMouseExitFromWidget))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("aMessage == eMouseOver || aMessage == eMouseEnter || aMessage == eMouseOut || aMessage == eMouseLeave || aMessage == ePointerOver || aMessage == ePointerEnter || aMessage == ePointerOut || aMessage == ePointerLeave || aMessage == eMouseEnterIntoWidget || aMessage == eMouseExitFromWidget"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 4688); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aMessage == eMouseOver || aMessage == eMouseEnter || aMessage == eMouseOut || aMessage == eMouseLeave || aMessage == ePointerOver || aMessage == ePointerEnter || aMessage == ePointerOut || aMessage == ePointerLeave || aMessage == eMouseEnterIntoWidget || aMessage == eMouseExitFromWidget"
")"); do { *((volatile int*)__null) = 4688; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
4684 aMessage == eMouseOut || aMessage == eMouseLeave ||do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aMessage == eMouseOver || aMessage == eMouseEnter ||
aMessage == eMouseOut || aMessage == eMouseLeave || aMessage
== ePointerOver || aMessage == ePointerEnter || aMessage == ePointerOut
|| aMessage == ePointerLeave || aMessage == eMouseEnterIntoWidget
|| aMessage == eMouseExitFromWidget)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aMessage == eMouseOver || aMessage
== eMouseEnter || aMessage == eMouseOut || aMessage == eMouseLeave
|| aMessage == ePointerOver || aMessage == ePointerEnter || aMessage
== ePointerOut || aMessage == ePointerLeave || aMessage == eMouseEnterIntoWidget
|| aMessage == eMouseExitFromWidget))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("aMessage == eMouseOver || aMessage == eMouseEnter || aMessage == eMouseOut || aMessage == eMouseLeave || aMessage == ePointerOver || aMessage == ePointerEnter || aMessage == ePointerOut || aMessage == ePointerLeave || aMessage == eMouseEnterIntoWidget || aMessage == eMouseExitFromWidget"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 4688); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aMessage == eMouseOver || aMessage == eMouseEnter || aMessage == eMouseOut || aMessage == eMouseLeave || aMessage == ePointerOver || aMessage == ePointerEnter || aMessage == ePointerOut || aMessage == ePointerLeave || aMessage == eMouseEnterIntoWidget || aMessage == eMouseExitFromWidget"
")"); do { *((volatile int*)__null) = 4688; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
4685 aMessage == ePointerOver || aMessage == ePointerEnter ||do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aMessage == eMouseOver || aMessage == eMouseEnter ||
aMessage == eMouseOut || aMessage == eMouseLeave || aMessage
== ePointerOver || aMessage == ePointerEnter || aMessage == ePointerOut
|| aMessage == ePointerLeave || aMessage == eMouseEnterIntoWidget
|| aMessage == eMouseExitFromWidget)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aMessage == eMouseOver || aMessage
== eMouseEnter || aMessage == eMouseOut || aMessage == eMouseLeave
|| aMessage == ePointerOver || aMessage == ePointerEnter || aMessage
== ePointerOut || aMessage == ePointerLeave || aMessage == eMouseEnterIntoWidget
|| aMessage == eMouseExitFromWidget))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("aMessage == eMouseOver || aMessage == eMouseEnter || aMessage == eMouseOut || aMessage == eMouseLeave || aMessage == ePointerOver || aMessage == ePointerEnter || aMessage == ePointerOut || aMessage == ePointerLeave || aMessage == eMouseEnterIntoWidget || aMessage == eMouseExitFromWidget"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 4688); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aMessage == eMouseOver || aMessage == eMouseEnter || aMessage == eMouseOut || aMessage == eMouseLeave || aMessage == ePointerOver || aMessage == ePointerEnter || aMessage == ePointerOut || aMessage == ePointerLeave || aMessage == eMouseEnterIntoWidget || aMessage == eMouseExitFromWidget"
")"); do { *((volatile int*)__null) = 4688; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
4686 aMessage == ePointerOut || aMessage == ePointerLeave ||do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aMessage == eMouseOver || aMessage == eMouseEnter ||
aMessage == eMouseOut || aMessage == eMouseLeave || aMessage
== ePointerOver || aMessage == ePointerEnter || aMessage == ePointerOut
|| aMessage == ePointerLeave || aMessage == eMouseEnterIntoWidget
|| aMessage == eMouseExitFromWidget)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aMessage == eMouseOver || aMessage
== eMouseEnter || aMessage == eMouseOut || aMessage == eMouseLeave
|| aMessage == ePointerOver || aMessage == ePointerEnter || aMessage
== ePointerOut || aMessage == ePointerLeave || aMessage == eMouseEnterIntoWidget
|| aMessage == eMouseExitFromWidget))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("aMessage == eMouseOver || aMessage == eMouseEnter || aMessage == eMouseOut || aMessage == eMouseLeave || aMessage == ePointerOver || aMessage == ePointerEnter || aMessage == ePointerOut || aMessage == ePointerLeave || aMessage == eMouseEnterIntoWidget || aMessage == eMouseExitFromWidget"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 4688); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aMessage == eMouseOver || aMessage == eMouseEnter || aMessage == eMouseOut || aMessage == eMouseLeave || aMessage == ePointerOver || aMessage == ePointerEnter || aMessage == ePointerOut || aMessage == ePointerLeave || aMessage == eMouseEnterIntoWidget || aMessage == eMouseExitFromWidget"
")"); do { *((volatile int*)__null) = 4688; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
4687 aMessage == eMouseEnterIntoWidget ||do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aMessage == eMouseOver || aMessage == eMouseEnter ||
aMessage == eMouseOut || aMessage == eMouseLeave || aMessage
== ePointerOver || aMessage == ePointerEnter || aMessage == ePointerOut
|| aMessage == ePointerLeave || aMessage == eMouseEnterIntoWidget
|| aMessage == eMouseExitFromWidget)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aMessage == eMouseOver || aMessage
== eMouseEnter || aMessage == eMouseOut || aMessage == eMouseLeave
|| aMessage == ePointerOver || aMessage == ePointerEnter || aMessage
== ePointerOut || aMessage == ePointerLeave || aMessage == eMouseEnterIntoWidget
|| aMessage == eMouseExitFromWidget))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("aMessage == eMouseOver || aMessage == eMouseEnter || aMessage == eMouseOut || aMessage == eMouseLeave || aMessage == ePointerOver || aMessage == ePointerEnter || aMessage == ePointerOut || aMessage == ePointerLeave || aMessage == eMouseEnterIntoWidget || aMessage == eMouseExitFromWidget"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 4688); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aMessage == eMouseOver || aMessage == eMouseEnter || aMessage == eMouseOut || aMessage == eMouseLeave || aMessage == ePointerOver || aMessage == ePointerEnter || aMessage == ePointerOut || aMessage == ePointerLeave || aMessage == eMouseEnterIntoWidget || aMessage == eMouseExitFromWidget"
")"); do { *((volatile int*)__null) = 4688; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
4688 aMessage == eMouseExitFromWidget)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aMessage == eMouseOver || aMessage == eMouseEnter ||
aMessage == eMouseOut || aMessage == eMouseLeave || aMessage
== ePointerOver || aMessage == ePointerEnter || aMessage == ePointerOut
|| aMessage == ePointerLeave || aMessage == eMouseEnterIntoWidget
|| aMessage == eMouseExitFromWidget)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aMessage == eMouseOver || aMessage
== eMouseEnter || aMessage == eMouseOut || aMessage == eMouseLeave
|| aMessage == ePointerOver || aMessage == ePointerEnter || aMessage
== ePointerOut || aMessage == ePointerLeave || aMessage == eMouseEnterIntoWidget
|| aMessage == eMouseExitFromWidget))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("aMessage == eMouseOver || aMessage == eMouseEnter || aMessage == eMouseOut || aMessage == eMouseLeave || aMessage == ePointerOver || aMessage == ePointerEnter || aMessage == ePointerOut || aMessage == ePointerLeave || aMessage == eMouseEnterIntoWidget || aMessage == eMouseExitFromWidget"
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 4688); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aMessage == eMouseOver || aMessage == eMouseEnter || aMessage == eMouseOut || aMessage == eMouseLeave || aMessage == ePointerOver || aMessage == ePointerEnter || aMessage == ePointerOut || aMessage == ePointerLeave || aMessage == eMouseEnterIntoWidget || aMessage == eMouseExitFromWidget"
")"); do { *((volatile int*)__null) = 4688; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
;
4689
4690 WidgetPointerEvent* sourcePointer = aMouseEvent->AsPointerEvent();
4691 UniquePtr<WidgetMouseEvent> newEvent;
4692 if (sourcePointer) {
4693 AUTO_PROFILER_LABEL("CreateMouseOrPointerWidgetEvent", OTHER)mozilla::AutoProfilerLabel raiiObject4693( "CreateMouseOrPointerWidgetEvent"
, nullptr, JS::ProfilingCategoryPair::OTHER)
;
4694
4695 WidgetPointerEvent* newPointerEvent = new WidgetPointerEvent(
4696 aMouseEvent->IsTrusted(), aMessage, aMouseEvent->mWidget);
4697 newPointerEvent->mIsPrimary = sourcePointer->mIsPrimary;
4698 newPointerEvent->mWidth = sourcePointer->mWidth;
4699 newPointerEvent->mHeight = sourcePointer->mHeight;
4700 newPointerEvent->mInputSource = sourcePointer->mInputSource;
4701
4702 newEvent = WrapUnique(newPointerEvent);
4703 } else {
4704 newEvent = MakeUnique<WidgetMouseEvent>(aMouseEvent->IsTrusted(), aMessage,
4705 aMouseEvent->mWidget,
4706 WidgetMouseEvent::eReal);
4707 }
4708
4709 // Inherit whether the event is synthesized by the test API or not.
4710 // Then, when the event is synthesized by a test API and handled in a remote
4711 // process, it won't be ignored. See PresShell::HandleEvent().
4712 newEvent->mFlags.mIsSynthesizedForTests =
4713 aMouseEvent->mFlags.mIsSynthesizedForTests;
4714
4715 newEvent->mRelatedTarget = aRelatedTarget;
4716 newEvent->mRefPoint = aMouseEvent->mRefPoint;
4717 newEvent->mModifiers = aMouseEvent->mModifiers;
4718 if (!aMouseEvent->mFlags.mDispatchedAtLeastOnce &&
4719 aMouseEvent->InputSourceSupportsHover()) {
4720 // If we synthesize a pointer event or a mouse event from another event
4721 // which changes a button state whose input soucre supports hover state and
4722 // the source event has not been dispatched yet, we should set to the button
4723 // state of the synthesizing event to previous one.
4724 // Note that we don't need to do this if the input source does not support
4725 // hover state because a WPT check the behavior (see below) and the other
4726 // browsers pass the test even though this is inconsistent behavior.
4727 newEvent->mButton =
4728 sourcePointer ? MouseButton::eNotPressed : MouseButton::ePrimary;
4729 if (aMouseEvent->IsPressingButton()) {
4730 // If the source event has not been dispatched into the DOM yet, we
4731 // need to remove the flag which is being pressed.
4732 newEvent->mButtons = static_cast<decltype(WidgetMouseEvent::mButtons)>(
4733 aMouseEvent->mButtons &
4734 ~MouseButtonsFlagToChange(
4735 static_cast<MouseButton>(aMouseEvent->mButton)));
4736 } else if (aMouseEvent->IsReleasingButton()) {
4737 // If the source event has not been dispatched into the DOM yet, we
4738 // need to add the flag which is being released.
4739 newEvent->mButtons = static_cast<decltype(WidgetMouseEvent::mButtons)>(
4740 aMouseEvent->mButtons |
4741 MouseButtonsFlagToChange(
4742 static_cast<MouseButton>(aMouseEvent->mButton)));
4743 } else {
4744 // The source event does not change the buttons state so that we can
4745 // set mButtons value as-is.
4746 newEvent->mButtons = aMouseEvent->mButtons;
4747 }
4748 // Adjust pressure if it does not matches with mButtons.
4749 // FIXME: We may use wrong pressure value if the source event has not been
4750 // dispatched into the DOM yet. However, fixing this requires to store the
4751 // last pressure value somewhere.
4752 if (newEvent->mButtons && aMouseEvent->mPressure == 0) {
4753 newEvent->mPressure = 0.5f;
4754 } else if (!newEvent->mButtons && aMouseEvent->mPressure != 0) {
4755 newEvent->mPressure = 0;
4756 } else {
4757 newEvent->mPressure = aMouseEvent->mPressure;
4758 }
4759 } else {
4760 // If the event has already been dispatched into the tree, web apps has
4761 // already handled the button state change, so the button state of the
4762 // source event has already synced.
4763 // If the input source does not have hover state, we don't need to modify
4764 // the state because the other browsers behave so and tested by
4765 // pointerevent_attributes_nohover_pointers.html even though this is
4766 // different expectation from
4767 // pointerevent_attributes_hoverable_pointers.html, but the other browsers
4768 // pass both of them.
4769 newEvent->mButton = aMouseEvent->mButton;
4770 newEvent->mButtons = aMouseEvent->mButtons;
4771 newEvent->mPressure = aMouseEvent->mPressure;
4772 }
4773
4774 newEvent->mInputSource = aMouseEvent->mInputSource;
4775 newEvent->pointerId = aMouseEvent->pointerId;
4776
4777 return newEvent;
4778}
4779
4780nsIFrame* EventStateManager::DispatchMouseOrPointerEvent(
4781 WidgetMouseEvent* aMouseEvent, EventMessage aMessage,
4782 nsIContent* aTargetContent, nsIContent* aRelatedContent) {
4783 // http://dvcs.w3.org/hg/webevents/raw-file/default/mouse-lock.html#methods
4784 // "[When the mouse is locked on an element...e]vents that require the concept
4785 // of a mouse cursor must not be dispatched (for example: mouseover,
4786 // mouseout).
4787 if (PointerLockManager::IsLocked() &&
4788 (aMessage == eMouseLeave || aMessage == eMouseEnter ||
4789 aMessage == eMouseOver || aMessage == eMouseOut)) {
4790 mCurrentTargetContent = nullptr;
4791 nsCOMPtr<Element> pointerLockedElement =
4792 PointerLockManager::GetLockedElement();
4793 if (!pointerLockedElement) {
4794 NS_WARNING("Should have pointer locked element, but didn't.")NS_DebugBreak(NS_DEBUG_WARNING, "Should have pointer locked element, but didn't."
, nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 4794)
;
4795 return nullptr;
4796 }
4797 return mPresContext->GetPrimaryFrameFor(pointerLockedElement);
4798 }
4799
4800 mCurrentTargetContent = nullptr;
4801
4802 if (!aTargetContent) {
4803 return nullptr;
4804 }
4805
4806 nsCOMPtr<nsIContent> targetContent = aTargetContent;
4807 nsCOMPtr<nsIContent> relatedContent = aRelatedContent;
4808
4809 UniquePtr<WidgetMouseEvent> dispatchEvent =
4810 CreateMouseOrPointerWidgetEvent(aMouseEvent, aMessage, relatedContent);
4811
4812 AutoWeakFrame previousTarget = mCurrentTarget;
4813 mCurrentTargetContent = targetContent;
4814
4815 nsIFrame* targetFrame = nullptr;
4816
4817 nsEventStatus status = nsEventStatus_eIgnore;
4818 ESMEventCB callback(targetContent);
4819 RefPtr<nsPresContext> presContext = mPresContext;
4820 EventDispatcher::Dispatch(targetContent, presContext, dispatchEvent.get(),
4821 nullptr, &status, &callback);
4822
4823 if (mPresContext) {
4824 // Although the primary frame was checked in event callback, it may not be
4825 // the same object after event dispatch and handling, so refetch it.
4826 targetFrame = mPresContext->GetPrimaryFrameFor(targetContent);
4827
4828 // If we are entering/leaving remote content, dispatch a mouse enter/exit
4829 // event to the remote frame.
4830 if (IsTopLevelRemoteTarget(targetContent)) {
4831 if (aMessage == eMouseOut) {
4832 // For remote content, send a puppet widget mouse exit event.
4833 UniquePtr<WidgetMouseEvent> remoteEvent =
4834 CreateMouseOrPointerWidgetEvent(aMouseEvent, eMouseExitFromWidget,
4835 relatedContent);
4836 remoteEvent->mExitFrom = Some(WidgetMouseEvent::ePuppet);
4837
4838 // mCurrentTarget is set to the new target, so we must reset it to the
4839 // old target and then dispatch a cross-process event. (mCurrentTarget
4840 // will be set back below.) HandleCrossProcessEvent will query for the
4841 // proper target via GetEventTarget which will return mCurrentTarget.
4842 mCurrentTarget = targetFrame;
4843 HandleCrossProcessEvent(remoteEvent.get(), &status);
4844 } else if (aMessage == eMouseOver) {
4845 UniquePtr<WidgetMouseEvent> remoteEvent =
4846 CreateMouseOrPointerWidgetEvent(aMouseEvent, eMouseEnterIntoWidget,
4847 relatedContent);
4848 HandleCrossProcessEvent(remoteEvent.get(), &status);
4849 }
4850 }
4851 }
4852
4853 mCurrentTargetContent = nullptr;
4854 mCurrentTarget = previousTarget;
4855
4856 return targetFrame;
4857}
4858
4859static nsIContent* FindCommonAncestor(nsIContent* aNode1, nsIContent* aNode2) {
4860 if (!aNode1 || !aNode2) {
4861 return nullptr;
4862 }
4863 return nsContentUtils::GetCommonFlattenedTreeAncestor(aNode1, aNode2);
4864}
4865
4866class EnterLeaveDispatcher {
4867 public:
4868 EnterLeaveDispatcher(EventStateManager* aESM, nsIContent* aTarget,
4869 nsIContent* aRelatedTarget,
4870 WidgetMouseEvent* aMouseEvent,
4871 EventMessage aEventMessage)
4872 : mESM(aESM), mMouseEvent(aMouseEvent), mEventMessage(aEventMessage) {
4873 nsPIDOMWindowInner* win =
4874 aTarget ? aTarget->OwnerDoc()->GetInnerWindow() : nullptr;
4875 if (aMouseEvent->AsPointerEvent()
4876 ? win && win->HasPointerEnterLeaveEventListeners()
4877 : win && win->HasMouseEnterLeaveEventListeners()) {
4878 mRelatedTarget =
4879 aRelatedTarget ? aRelatedTarget->FindFirstNonChromeOnlyAccessContent()
4880 : nullptr;
4881 nsINode* commonParent = FindCommonAncestor(aTarget, aRelatedTarget);
4882 nsIContent* current = aTarget;
4883 // Note, it is ok if commonParent is null!
4884 while (current && current != commonParent) {
4885 if (!current->ChromeOnlyAccess()) {
4886 mTargets.AppendObject(current);
4887 }
4888 // mouseenter/leave is fired only on elements.
4889 current = current->GetFlattenedTreeParent();
4890 }
4891 }
4892 }
4893
4894 // TODO: Convert this to MOZ_CAN_RUN_SCRIPT (bug 1415230)
4895 MOZ_CAN_RUN_SCRIPT_BOUNDARY void Dispatch() {
4896 if (mEventMessage == eMouseEnter || mEventMessage == ePointerEnter) {
4897 for (int32_t i = mTargets.Count() - 1; i >= 0; --i) {
4898 mESM->DispatchMouseOrPointerEvent(mMouseEvent, mEventMessage,
4899 MOZ_KnownLive(mTargets[i])(mTargets[i]),
4900 mRelatedTarget);
4901 }
4902 } else {
4903 for (int32_t i = 0; i < mTargets.Count(); ++i) {
4904 mESM->DispatchMouseOrPointerEvent(mMouseEvent, mEventMessage,
4905 MOZ_KnownLive(mTargets[i])(mTargets[i]),
4906 mRelatedTarget);
4907 }
4908 }
4909 }
4910
4911 // Nothing overwrites anything after constructor. Please remove MOZ_KnownLive
4912 // and MOZ_KNOWN_LIVE if anything marked as such becomes mutable.
4913 const RefPtr<EventStateManager> mESM;
4914 nsCOMArray<nsIContent> mTargets;
4915 MOZ_KNOWN_LIVE nsCOMPtr<nsIContent> mRelatedTarget;
4916 WidgetMouseEvent* mMouseEvent;
4917 EventMessage mEventMessage;
4918};
4919
4920void EventStateManager::NotifyMouseOut(WidgetMouseEvent* aMouseEvent,
4921 nsIContent* aMovingInto) {
4922 const bool isPointer = aMouseEvent->mClass == ePointerEventClass;
4923 LogModule* const logModule =
4924 isPointer ? sPointerBoundaryLog : sMouseBoundaryLog;
4925
4926 RefPtr<OverOutElementsWrapper> wrapper = GetWrapperByEventID(aMouseEvent);
4927
4928 // If there is no deepest "leave" event target, that means the last "over"
4929 // target has already been removed from the tree. Therefore, checking only
4930 // the "leave" event target is enough.
4931 if (!wrapper || !wrapper->GetDeepestLeaveEventTarget()) {
4932 return;
4933 }
4934 // Before firing "out" and/or "leave" events, check for recursion
4935 if (wrapper->IsDispatchingOutEventOnLastOverEventTarget()) {
4936 return;
4937 }
4938
4939 MOZ_LOG(logModule, LogLevel::Info,do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "NotifyMouseOut: the source event is %s (IsReal()=%s)"
, ToChar(aMouseEvent->mMessage), aMouseEvent->IsReal() ?
"true" : "false"); } } while (0)
4940 ("NotifyMouseOut: the source event is %s (IsReal()=%s)",do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "NotifyMouseOut: the source event is %s (IsReal()=%s)"
, ToChar(aMouseEvent->mMessage), aMouseEvent->IsReal() ?
"true" : "false"); } } while (0)
4941 ToChar(aMouseEvent->mMessage),do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "NotifyMouseOut: the source event is %s (IsReal()=%s)"
, ToChar(aMouseEvent->mMessage), aMouseEvent->IsReal() ?
"true" : "false"); } } while (0)
4942 aMouseEvent->IsReal() ? "true" : "false"))do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "NotifyMouseOut: the source event is %s (IsReal()=%s)"
, ToChar(aMouseEvent->mMessage), aMouseEvent->IsReal() ?
"true" : "false"); } } while (0)
;
4943
4944 // XXX If a content node is a container of remove content, it should be
4945 // replaced with them and its children should not be visible. Therefore,
4946 // if the deepest "enter" target is not the last "over" target, i.e., the
4947 // last "over" target has been removed from the DOM tree, it means that the
4948 // child/descendant was not replaced by remote content. So,
4949 // wrapper->GetOutEventTaget() may be enough here.
4950 if (RefPtr<nsFrameLoaderOwner> flo =
4951 do_QueryObject(wrapper->GetDeepestLeaveEventTarget())) {
4952 if (BrowsingContext* bc = flo->GetExtantBrowsingContext()) {
4953 if (nsIDocShell* docshell = bc->GetDocShell()) {
4954 if (RefPtr<nsPresContext> presContext = docshell->GetPresContext()) {
4955 EventStateManager* kidESM = presContext->EventStateManager();
4956 // Not moving into any element in this subdocument
4957 MOZ_LOG(logModule, LogLevel::Info,do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Notifying child EventStateManager (%p) of \"out\" "
"event...", kidESM); } } while (0)
4958 ("Notifying child EventStateManager (%p) of \"out\" "do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Notifying child EventStateManager (%p) of \"out\" "
"event...", kidESM); } } while (0)
4959 "event...",do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Notifying child EventStateManager (%p) of \"out\" "
"event...", kidESM); } } while (0)
4960 kidESM))do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Notifying child EventStateManager (%p) of \"out\" "
"event...", kidESM); } } while (0)
;
4961 kidESM->NotifyMouseOut(aMouseEvent, nullptr);
4962 }
4963 }
4964 }
4965 }
4966 // That could have caused DOM events which could wreak havoc. Reverify
4967 // things and be careful.
4968 if (!wrapper->GetDeepestLeaveEventTarget()) {
4969 return;
4970 }
4971
4972 wrapper->WillDispatchOutAndOrLeaveEvent();
4973
4974 // Don't touch hover state if aMovingInto is non-null. Caller will update
4975 // hover state itself, and we have optimizations for hover switching between
4976 // two nearby elements both deep in the DOM tree that would be defeated by
4977 // switching the hover state to null here.
4978 if (!aMovingInto && !isPointer) {
4979 // Unset :hover
4980 SetContentState(nullptr, ElementState::HOVER);
4981 }
4982
4983 EnterLeaveDispatcher leaveDispatcher(
4984 this, wrapper->GetDeepestLeaveEventTarget(), aMovingInto, aMouseEvent,
4985 isPointer ? ePointerLeave : eMouseLeave);
4986
4987 // "out" events hould be fired only when the deepest "leave" event target
4988 // is the last "over" event target.
4989 if (nsCOMPtr<nsIContent> outEventTarget = wrapper->GetOutEventTarget()) {
4990 MOZ_LOG(logModule, LogLevel::Info,do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Dispatching %s event to %s (%p)", isPointer
? "ePointerOut" : "eMouseOut", outEventTarget ? ToString(*outEventTarget
).c_str() : "nullptr", outEventTarget.get()); } } while (0)
4991 ("Dispatching %s event to %s (%p)",do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Dispatching %s event to %s (%p)", isPointer
? "ePointerOut" : "eMouseOut", outEventTarget ? ToString(*outEventTarget
).c_str() : "nullptr", outEventTarget.get()); } } while (0)
4992 isPointer ? "ePointerOut" : "eMouseOut",do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Dispatching %s event to %s (%p)", isPointer
? "ePointerOut" : "eMouseOut", outEventTarget ? ToString(*outEventTarget
).c_str() : "nullptr", outEventTarget.get()); } } while (0)
4993 outEventTarget ? ToString(*outEventTarget).c_str() : "nullptr",do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Dispatching %s event to %s (%p)", isPointer
? "ePointerOut" : "eMouseOut", outEventTarget ? ToString(*outEventTarget
).c_str() : "nullptr", outEventTarget.get()); } } while (0)
4994 outEventTarget.get()))do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Dispatching %s event to %s (%p)", isPointer
? "ePointerOut" : "eMouseOut", outEventTarget ? ToString(*outEventTarget
).c_str() : "nullptr", outEventTarget.get()); } } while (0)
;
4995 DispatchMouseOrPointerEvent(aMouseEvent,
4996 isPointer ? ePointerOut : eMouseOut,
4997 outEventTarget, aMovingInto);
4998 }
4999
5000 MOZ_LOG(logModule, LogLevel::Info,do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Dispatching %s event to %s (%p) and its ancestors"
, isPointer ? "ePointerLeave" : "eMouseLeave", wrapper->GetDeepestLeaveEventTarget
() ? ToString(*wrapper->GetDeepestLeaveEventTarget()).c_str
() : "nullptr", wrapper->GetDeepestLeaveEventTarget()); } }
while (0)
5001 ("Dispatching %s event to %s (%p) and its ancestors",do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Dispatching %s event to %s (%p) and its ancestors"
, isPointer ? "ePointerLeave" : "eMouseLeave", wrapper->GetDeepestLeaveEventTarget
() ? ToString(*wrapper->GetDeepestLeaveEventTarget()).c_str
() : "nullptr", wrapper->GetDeepestLeaveEventTarget()); } }
while (0)
5002 isPointer ? "ePointerLeave" : "eMouseLeave",do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Dispatching %s event to %s (%p) and its ancestors"
, isPointer ? "ePointerLeave" : "eMouseLeave", wrapper->GetDeepestLeaveEventTarget
() ? ToString(*wrapper->GetDeepestLeaveEventTarget()).c_str
() : "nullptr", wrapper->GetDeepestLeaveEventTarget()); } }
while (0)
5003 wrapper->GetDeepestLeaveEventTarget()do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Dispatching %s event to %s (%p) and its ancestors"
, isPointer ? "ePointerLeave" : "eMouseLeave", wrapper->GetDeepestLeaveEventTarget
() ? ToString(*wrapper->GetDeepestLeaveEventTarget()).c_str
() : "nullptr", wrapper->GetDeepestLeaveEventTarget()); } }
while (0)
5004 ? ToString(*wrapper->GetDeepestLeaveEventTarget()).c_str()do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Dispatching %s event to %s (%p) and its ancestors"
, isPointer ? "ePointerLeave" : "eMouseLeave", wrapper->GetDeepestLeaveEventTarget
() ? ToString(*wrapper->GetDeepestLeaveEventTarget()).c_str
() : "nullptr", wrapper->GetDeepestLeaveEventTarget()); } }
while (0)
5005 : "nullptr",do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Dispatching %s event to %s (%p) and its ancestors"
, isPointer ? "ePointerLeave" : "eMouseLeave", wrapper->GetDeepestLeaveEventTarget
() ? ToString(*wrapper->GetDeepestLeaveEventTarget()).c_str
() : "nullptr", wrapper->GetDeepestLeaveEventTarget()); } }
while (0)
5006 wrapper->GetDeepestLeaveEventTarget()))do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Dispatching %s event to %s (%p) and its ancestors"
, isPointer ? "ePointerLeave" : "eMouseLeave", wrapper->GetDeepestLeaveEventTarget
() ? ToString(*wrapper->GetDeepestLeaveEventTarget()).c_str
() : "nullptr", wrapper->GetDeepestLeaveEventTarget()); } }
while (0)
;
5007 leaveDispatcher.Dispatch();
5008
5009 MOZ_LOG(logModule, LogLevel::Info,do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Dispatched \"out\" and/or \"leave\" events"
); } } while (0)
5010 ("Dispatched \"out\" and/or \"leave\" events"))do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Dispatched \"out\" and/or \"leave\" events"
); } } while (0)
;
5011 wrapper->DidDispatchOutAndOrLeaveEvent();
5012}
5013
5014void EventStateManager::RecomputeMouseEnterStateForRemoteFrame(
5015 Element& aElement) {
5016 if (!mMouseEnterLeaveHelper ||
5017 mMouseEnterLeaveHelper->GetDeepestLeaveEventTarget() != &aElement) {
5018 return;
5019 }
5020
5021 if (BrowserParent* remote = BrowserParent::GetFrom(&aElement)) {
5022 remote->MouseEnterIntoWidget();
5023 }
5024}
5025
5026void EventStateManager::NotifyMouseOver(WidgetMouseEvent* aMouseEvent,
5027 nsIContent* aContent) {
5028 NS_ASSERTION(aContent, "Mouse must be over something")do { if (!(aContent)) { NS_DebugBreak(NS_DEBUG_ASSERTION, "Mouse must be over something"
, "aContent", "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 5028); MOZ_PretendNoReturn(); } } while (0)
;
5029
5030 const bool isPointer = aMouseEvent->mClass == ePointerEventClass;
5031 LogModule* const logModule =
5032 isPointer ? sPointerBoundaryLog : sMouseBoundaryLog;
5033
5034 RefPtr<OverOutElementsWrapper> wrapper = GetWrapperByEventID(aMouseEvent);
5035
5036 // If we have next "out" event target and it's the new "over" target, we don't
5037 // need to dispatch "out" nor "enter" event.
5038 if (!wrapper || aContent == wrapper->GetOutEventTarget()) {
5039 return;
5040 }
5041
5042 // Before firing "over" and "enter" events, check for recursion
5043 if (wrapper->IsDispatchingOverEventOn(aContent)) {
5044 return;
5045 }
5046
5047 MOZ_LOG(logModule, LogLevel::Info,do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "NotifyMouseOver: the source event is %s (IsReal()=%s)"
, ToChar(aMouseEvent->mMessage), aMouseEvent->IsReal() ?
"true" : "false"); } } while (0)
5048 ("NotifyMouseOver: the source event is %s (IsReal()=%s)",do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "NotifyMouseOver: the source event is %s (IsReal()=%s)"
, ToChar(aMouseEvent->mMessage), aMouseEvent->IsReal() ?
"true" : "false"); } } while (0)
5049 ToChar(aMouseEvent->mMessage),do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "NotifyMouseOver: the source event is %s (IsReal()=%s)"
, ToChar(aMouseEvent->mMessage), aMouseEvent->IsReal() ?
"true" : "false"); } } while (0)
5050 aMouseEvent->IsReal() ? "true" : "false"))do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "NotifyMouseOver: the source event is %s (IsReal()=%s)"
, ToChar(aMouseEvent->mMessage), aMouseEvent->IsReal() ?
"true" : "false"); } } while (0)
;
5051
5052 // Check to see if we're a subdocument and if so update the parent
5053 // document's ESM state to indicate that the mouse is over the
5054 // content associated with our subdocument.
5055 EnsureDocument(mPresContext);
5056 if (Document* parentDoc = mDocument->GetInProcessParentDocument()) {
5057 if (nsCOMPtr<nsIContent> docContent = mDocument->GetEmbedderElement()) {
5058 if (PresShell* parentPresShell = parentDoc->GetPresShell()) {
5059 RefPtr<EventStateManager> parentESM =
5060 parentPresShell->GetPresContext()->EventStateManager();
5061 MOZ_LOG(logModule, LogLevel::Info,do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Notifying parent EventStateManager (%p) of \"over\" "
"event...", parentESM.get()); } } while (0)
5062 ("Notifying parent EventStateManager (%p) of \"over\" "do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Notifying parent EventStateManager (%p) of \"over\" "
"event...", parentESM.get()); } } while (0)
5063 "event...",do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Notifying parent EventStateManager (%p) of \"over\" "
"event...", parentESM.get()); } } while (0)
5064 parentESM.get()))do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Notifying parent EventStateManager (%p) of \"over\" "
"event...", parentESM.get()); } } while (0)
;
5065 parentESM->NotifyMouseOver(aMouseEvent, docContent);
5066 }
5067 }
5068 }
5069 // Firing the DOM event in the parent document could cause all kinds
5070 // of havoc. Reverify and take care.
5071 if (aContent == wrapper->GetOutEventTarget()) {
5072 return;
5073 }
5074
5075 // Remember the deepest leave event target as the related content for the
5076 // DispatchMouseOrPointerEvent() call below, since NotifyMouseOut() resets it,
5077 // bug 298477.
5078 nsCOMPtr<nsIContent> deepestLeaveEventTarget =
5079 wrapper->GetDeepestLeaveEventTarget();
5080
5081 EnterLeaveDispatcher enterDispatcher(this, aContent, deepestLeaveEventTarget,
5082 aMouseEvent,
5083 isPointer ? ePointerEnter : eMouseEnter);
5084
5085 if (!isPointer) {
5086 SetContentState(aContent, ElementState::HOVER);
5087 }
5088
5089 NotifyMouseOut(aMouseEvent, aContent);
5090
5091 wrapper->WillDispatchOverAndEnterEvent(aContent);
5092
5093 // Fire mouseover
5094 // XXX If aContent has already been removed from the DOM tree, what should we
5095 // do? At least, dispatching `mouseover` on it is odd.
5096 MOZ_LOG(logModule, LogLevel::Info,do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Dispatching %s event to %s (%p)", isPointer
? "ePointerOver" : "eMoustOver", aContent ? ToString(*aContent
).c_str() : "nullptr", aContent); } } while (0)
5097 ("Dispatching %s event to %s (%p)",do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Dispatching %s event to %s (%p)", isPointer
? "ePointerOver" : "eMoustOver", aContent ? ToString(*aContent
).c_str() : "nullptr", aContent); } } while (0)
5098 isPointer ? "ePointerOver" : "eMoustOver",do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Dispatching %s event to %s (%p)", isPointer
? "ePointerOver" : "eMoustOver", aContent ? ToString(*aContent
).c_str() : "nullptr", aContent); } } while (0)
5099 aContent ? ToString(*aContent).c_str() : "nullptr", aContent))do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Dispatching %s event to %s (%p)", isPointer
? "ePointerOver" : "eMoustOver", aContent ? ToString(*aContent
).c_str() : "nullptr", aContent); } } while (0)
;
5100 wrapper->mLastOverFrame = DispatchMouseOrPointerEvent(
5101 aMouseEvent, isPointer ? ePointerOver : eMouseOver, aContent,
5102 deepestLeaveEventTarget);
5103
5104 MOZ_LOG(logModule, LogLevel::Info,do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Dispatching %s event to %s (%p) and its ancestors"
, isPointer ? "ePointerEnter" : "eMouseEnter", aContent ? ToString
(*aContent).c_str() : "nullptr", aContent); } } while (0)
5105 ("Dispatching %s event to %s (%p) and its ancestors",do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Dispatching %s event to %s (%p) and its ancestors"
, isPointer ? "ePointerEnter" : "eMouseEnter", aContent ? ToString
(*aContent).c_str() : "nullptr", aContent); } } while (0)
5106 isPointer ? "ePointerEnter" : "eMouseEnter",do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Dispatching %s event to %s (%p) and its ancestors"
, isPointer ? "ePointerEnter" : "eMouseEnter", aContent ? ToString
(*aContent).c_str() : "nullptr", aContent); } } while (0)
5107 aContent ? ToString(*aContent).c_str() : "nullptr", aContent))do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Dispatching %s event to %s (%p) and its ancestors"
, isPointer ? "ePointerEnter" : "eMouseEnter", aContent ? ToString
(*aContent).c_str() : "nullptr", aContent); } } while (0)
;
5108 enterDispatcher.Dispatch();
5109
5110 MOZ_LOG(logModule, LogLevel::Info,do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Dispatched \"over\" and \"enter\" events (the original \"over\" "
"event target was in the document %p, and now in %p)", aContent
->GetComposedDoc(), mDocument.get()); } } while (0)
5111 ("Dispatched \"over\" and \"enter\" events (the original \"over\" "do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Dispatched \"over\" and \"enter\" events (the original \"over\" "
"event target was in the document %p, and now in %p)", aContent
->GetComposedDoc(), mDocument.get()); } } while (0)
5112 "event target was in the document %p, and now in %p)",do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Dispatched \"over\" and \"enter\" events (the original \"over\" "
"event target was in the document %p, and now in %p)", aContent
->GetComposedDoc(), mDocument.get()); } } while (0)
5113 aContent->GetComposedDoc(), mDocument.get()))do { const ::mozilla::LogModule* moz_real_module = logModule;
if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module
, LogLevel::Info)), 0))) { mozilla::detail::log_print(moz_real_module
, LogLevel::Info, "Dispatched \"over\" and \"enter\" events (the original \"over\" "
"event target was in the document %p, and now in %p)", aContent
->GetComposedDoc(), mDocument.get()); } } while (0)
;
5114 wrapper->DidDispatchOverAndEnterEvent(
5115 aContent->GetComposedDoc() == mDocument ? aContent : nullptr);
5116}
5117
5118// Returns the center point of the window's client area. This is
5119// in widget coordinates, i.e. relative to the widget's top-left
5120// corner, not in screen coordinates, the same units that UIEvent::
5121// refpoint is in. It may not be the exact center of the window if
5122// the platform requires rounding the coordinate.
5123static LayoutDeviceIntPoint GetWindowClientRectCenter(nsIWidget* aWidget) {
5124 NS_ENSURE_TRUE(aWidget, LayoutDeviceIntPoint(0, 0))do { if ((__builtin_expect(!!(!(aWidget)), 0))) { NS_DebugBreak
(NS_DEBUG_WARNING, "NS_ENSURE_TRUE(" "aWidget" ") failed", nullptr
, "/var/lib/jenkins/workspace/firefox-scan-build/dom/events/EventStateManager.cpp"
, 5124); return LayoutDeviceIntPoint(0, 0); } } while (false)
;
5125
5126 LayoutDeviceIntRect rect = aWidget->GetClientBounds();
5127 LayoutDeviceIntPoint point(rect.x + rect.width / 2, rect.y + rect.height / 2);
5128 int32_t round = aWidget->RoundsWidgetCoordinatesTo();
5129 point.x = point.x / round * round;
5130 point.y = point.y / round * round;
5131 return point - aWidget->WidgetToScreenOffset();
5132}
5133
5134void EventStateManager::GeneratePointerEnterExit(EventMessage aMessage,
5135 WidgetMouseEvent* aEvent) {
5136 WidgetPointerEvent pointerEvent(*aEvent);
5137 pointerEvent.mMessage = aMessage;
5138 GenerateMouseEnterExit(&pointerEvent);
5139}
5140
5141/* static */
5142void EventStateManager::UpdateLastRefPointOfMouseEvent(
5143 WidgetMouseEvent* aMouseEvent) {
5144 if (aMouseEvent->mMessage != eMouseMove &&
5145 aMouseEvent->mMessage != ePointerMove) {
5146 return;
5147 }
5148
5149 // Mouse movement is reported on the MouseEvent.movement{X,Y} fields.
5150 // Movement is calculated in UIEvent::GetMovementPoint() as:
5151 // previous_mousemove_mRefPoint - current_mousemove_mRefPoint.
5152 if (PointerLockManager::IsLocked() && aMouseEvent->mWidget) {
5153 // The pointer is locked. If the pointer is not located at the center of
5154 // the window, dispatch a synthetic mousemove to return the pointer there.
5155 // Doing this between "real" pointer moves gives the impression that the
5156 // (locked) pointer can continue moving and won't stop at the screen
5157 // boundary. We cancel the synthetic event so that we don't end up
5158 // dispatching the centering move event to content.
5159 aMouseEvent->mLastRefPoint =
5160 GetWindowClientRectCenter(aMouseEvent->mWidget);
5161
5162 } else if (sLastRefPoint == kInvalidRefPoint) {
5163 // We don't have a valid previous mousemove mRefPoint. This is either