--- a/dom/base/Element.cpp
+++ b/dom/base/Element.cpp
@@ -2078,17 +2078,17 @@ Element::DispatchClickEvent(nsPresContex
bool aFullDispatch,
const EventFlags* aExtraEventFlags,
nsEventStatus* aStatus)
{
NS_PRECONDITION(aTarget, "Must have target");
NS_PRECONDITION(aSourceEvent, "Must have source event");
NS_PRECONDITION(aStatus, "Null out param?");
- WidgetMouseEvent event(aSourceEvent->mFlags.mIsTrusted, eMouseClick,
+ WidgetMouseEvent event(aSourceEvent->IsTrusted(), eMouseClick,
aSourceEvent->widget, WidgetMouseEvent::eReal);
event.refPoint = aSourceEvent->refPoint;
uint32_t clickCount = 1;
float pressure = 0;
uint16_t inputSource = 0;
WidgetMouseEvent* sourceMouseEvent = aSourceEvent->AsMouseEvent();
if (sourceMouseEvent) {
clickCount = sourceMouseEvent->clickCount;
@@ -2873,17 +2873,17 @@ Element::Describe(nsAString& aOutDescrip
}
}
bool
Element::CheckHandleEventForLinksPrecondition(EventChainVisitor& aVisitor,
nsIURI** aURI) const
{
if (aVisitor.mEventStatus == nsEventStatus_eConsumeNoDefault ||
- (!aVisitor.mEvent->mFlags.mIsTrusted &&
+ (!aVisitor.mEvent->IsTrusted() &&
(aVisitor.mEvent->mMessage != eMouseClick) &&
(aVisitor.mEvent->mMessage != eKeyPress) &&
(aVisitor.mEvent->mMessage != eLegacyDOMActivate)) ||
!aVisitor.mPresContext ||
aVisitor.mEvent->mFlags.mMultipleActionsPrevented) {
return false;
}
--- a/dom/base/nsContentUtils.cpp
+++ b/dom/base/nsContentUtils.cpp
@@ -5222,18 +5222,19 @@ nsContentUtils::GetDragSession()
dragService->GetCurrentSession(getter_AddRefs(dragSession));
return dragSession.forget();
}
/* static */
nsresult
nsContentUtils::SetDataTransferInEvent(WidgetDragEvent* aDragEvent)
{
- if (aDragEvent->dataTransfer || !aDragEvent->mFlags.mIsTrusted)
+ if (aDragEvent->dataTransfer || !aDragEvent->IsTrusted()) {
return NS_OK;
+ }
// For draggesture and dragstart events, the data transfer object is
// created before the event fires, so it should already be set. For other
// drag events, get the object from the drag session.
NS_ASSERTION(aDragEvent->mMessage != eLegacyDragGesture &&
aDragEvent->mMessage != eDragStart,
"draggesture event created without a dataTransfer");
--- a/dom/base/nsGlobalWindow.cpp
+++ b/dom/base/nsGlobalWindow.cpp
@@ -3114,44 +3114,44 @@ nsGlobalWindow::PreHandleEvent(EventChai
int16_t myCoord[2];
myCoord[0] = aVisitor.mEvent->refPoint.x;
myCoord[1] = aVisitor.mEvent->refPoint.y;
gEntropyCollector->RandomUpdate((void*)myCoord, sizeof(myCoord));
gEntropyCollector->RandomUpdate((void*)&(aVisitor.mEvent->time),
sizeof(uint32_t));
}
- } else if (msg == eResize && aVisitor.mEvent->mFlags.mIsTrusted) {
+ } else if (msg == eResize && aVisitor.mEvent->IsTrusted()) {
// QIing to window so that we can keep the old behavior also in case
// a child window is handling resize.
nsCOMPtr<nsPIDOMWindowInner> window =
do_QueryInterface(aVisitor.mEvent->originalTarget);
if (window) {
mIsHandlingResizeEvent = true;
}
- } else if (msg == eMouseDown && aVisitor.mEvent->mFlags.mIsTrusted) {
+ } else if (msg == eMouseDown && aVisitor.mEvent->IsTrusted()) {
gMouseDown = true;
} else if ((msg == eMouseUp || msg == eDragEnd) &&
- aVisitor.mEvent->mFlags.mIsTrusted) {
+ aVisitor.mEvent->IsTrusted()) {
gMouseDown = false;
if (gDragServiceDisabled) {
nsCOMPtr<nsIDragService> ds =
do_GetService("@mozilla.org/widget/dragservice;1");
if (ds) {
gDragServiceDisabled = false;
ds->Unsuppress();
}
}
}
aVisitor.mParentTarget = GetParentTarget();
// Handle 'active' event.
if (!mIdleObservers.IsEmpty() &&
- aVisitor.mEvent->mFlags.mIsTrusted &&
+ aVisitor.mEvent->IsTrusted() &&
(aVisitor.mEvent->HasMouseEventMessage() ||
aVisitor.mEvent->HasDragEventMessage())) {
mAddActiveEventFuzzTime = false;
}
return NS_OK;
}
@@ -3319,38 +3319,38 @@ nsGlobalWindow::PostHandleEvent(EventCha
function under some circumstances (events that destroy the window)
without this addref. */
nsCOMPtr<nsIDOMEventTarget> kungFuDeathGrip1(mChromeEventHandler);
nsCOMPtr<nsIScriptContext> kungFuDeathGrip2(GetContextInternal());
if (aVisitor.mEvent->mMessage == eResize) {
mIsHandlingResizeEvent = false;
} else if (aVisitor.mEvent->mMessage == eUnload &&
- aVisitor.mEvent->mFlags.mIsTrusted) {
+ aVisitor.mEvent->IsTrusted()) {
// Execute bindingdetached handlers before we tear ourselves
// down.
if (mDoc) {
mDoc->BindingManager()->ExecuteDetachedHandlers();
}
mIsDocumentLoaded = false;
} else if (aVisitor.mEvent->mMessage == eLoad &&
- aVisitor.mEvent->mFlags.mIsTrusted) {
+ aVisitor.mEvent->IsTrusted()) {
// This is page load event since load events don't propagate to |window|.
// @see nsDocument::PreHandleEvent.
mIsDocumentLoaded = true;
nsCOMPtr<Element> element = GetOuterWindow()->GetFrameElementInternal();
nsIDocShell* docShell = GetDocShell();
if (element && GetParentInternal() &&
docShell && docShell->ItemType() != nsIDocShellTreeItem::typeChrome) {
// If we're not in chrome, or at a chrome boundary, fire the
// onload event for the frame element.
nsEventStatus status = nsEventStatus_eIgnore;
- WidgetEvent event(aVisitor.mEvent->mFlags.mIsTrusted, eLoad);
+ WidgetEvent event(aVisitor.mEvent->IsTrusted(), eLoad);
event.mFlags.mBubbles = false;
// Most of the time we could get a pres context to pass in here,
// but not always (i.e. if this window is not shown there won't
// be a pres context available). Since we're not firing a GUI
// event we don't need a pres context anyway so we just pass
// null as the pres context all the time here.
EventDispatcher::Dispatch(element, nullptr, &event, nullptr, &status);
--- a/dom/events/AsyncEventDispatcher.cpp
+++ b/dom/events/AsyncEventDispatcher.cpp
@@ -25,17 +25,17 @@ AsyncEventDispatcher::AsyncEventDispatch
: mTarget(aTarget)
{
MOZ_ASSERT(mTarget);
RefPtr<Event> event =
EventDispatcher::CreateEvent(aTarget, nullptr, &aEvent, EmptyString());
mEvent = do_QueryInterface(event);
NS_ASSERTION(mEvent, "Should never fail to create an event");
mEvent->DuplicatePrivateData();
- mEvent->SetTrusted(aEvent.mFlags.mIsTrusted);
+ mEvent->SetTrusted(aEvent.IsTrusted());
}
NS_IMETHODIMP
AsyncEventDispatcher::Run()
{
if (mCanceled) {
return NS_OK;
}
--- a/dom/events/Event.cpp
+++ b/dom/events/Event.cpp
@@ -738,17 +738,17 @@ Event::GetEventPopupControlState(WidgetE
abuse = openControlled;
break;
default:
break;
}
}
break;
case eKeyboardEventClass:
- if (aEvent->mFlags.mIsTrusted) {
+ if (aEvent->IsTrusted()) {
uint32_t key = aEvent->AsKeyboardEvent()->keyCode;
switch(aEvent->mMessage) {
case eKeyPress:
// return key on focused button. see note at eMouseClick.
if (key == nsIDOMKeyEvent::DOM_VK_RETURN) {
abuse = openAllowed;
} else if (PopupAllowedForEvent("keypress")) {
abuse = openControlled;
@@ -768,17 +768,17 @@ Event::GetEventPopupControlState(WidgetE
}
break;
default:
break;
}
}
break;
case eTouchEventClass:
- if (aEvent->mFlags.mIsTrusted) {
+ if (aEvent->IsTrusted()) {
switch (aEvent->mMessage) {
case eTouchStart:
if (PopupAllowedForEvent("touchstart")) {
abuse = openControlled;
}
break;
case eTouchEnd:
if (PopupAllowedForEvent("touchend")) {
@@ -786,17 +786,17 @@ Event::GetEventPopupControlState(WidgetE
}
break;
default:
break;
}
}
break;
case eMouseEventClass:
- if (aEvent->mFlags.mIsTrusted &&
+ if (aEvent->IsTrusted() &&
aEvent->AsMouseEvent()->button == WidgetMouseEvent::eLeftButton) {
switch(aEvent->mMessage) {
case eMouseUp:
if (PopupAllowedForEvent("mouseup")) {
abuse = openControlled;
}
break;
case eMouseDown:
--- a/dom/events/Event.h
+++ b/dom/events/Event.h
@@ -192,17 +192,17 @@ public:
bool MultipleActionsPrevented() const
{
return mEvent->mFlags.mMultipleActionsPrevented;
}
bool IsTrusted() const
{
- return mEvent->mFlags.mIsTrusted;
+ return mEvent->IsTrusted();
}
bool IsSynthesized() const
{
return mEvent->mFlags.mIsSynthesizedForTests;
}
double TimeStamp() const;
--- a/dom/events/EventListenerManager.cpp
+++ b/dom/events/EventListenerManager.cpp
@@ -1217,18 +1217,17 @@ EventListenerManager::HandleEventInterna
Listener* listener = &iter.GetNext();
// Check that the phase is same in event and event listener.
// Handle only trusted events, except when listener permits untrusted events.
if (ListenerCanHandle(listener, aEvent, eventMessage)) {
hasListener = true;
hasListenerForCurrentGroup = hasListenerForCurrentGroup ||
listener->mFlags.mInSystemGroup == aEvent->mFlags.mInSystemGroup;
if (listener->IsListening(aEvent) &&
- (aEvent->mFlags.mIsTrusted ||
- listener->mFlags.mAllowUntrustedEvents)) {
+ (aEvent->IsTrusted() || listener->mFlags.mAllowUntrustedEvents)) {
if (!*aDOMEvent) {
// This is tiny bit slow, but happens only once per event.
nsCOMPtr<EventTarget> et =
do_QueryInterface(aEvent->originalTarget);
RefPtr<Event> event = EventDispatcher::CreateEvent(et, aPresContext,
aEvent,
EmptyString());
event.forget(aDOMEvent);
--- a/dom/events/EventStateManager.cpp
+++ b/dom/events/EventStateManager.cpp
@@ -523,17 +523,17 @@ EventStateManager::PreHandleEvent(nsPres
"aTargetFrame should be related with aTargetContent");
mCurrentTarget = aTargetFrame;
mCurrentTargetContent = nullptr;
// Do not take account eMouseEnterIntoWidget/ExitFromWidget so that loading
// a page when user is not active doesn't change the state to active.
WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent();
- if (aEvent->mFlags.mIsTrusted &&
+ if (aEvent->IsTrusted() &&
((mouseEvent && mouseEvent->IsReal() &&
IsMessageMouseUserActivity(mouseEvent->mMessage)) ||
aEvent->mClass == eWheelEventClass ||
aEvent->mClass == ePointerEventClass ||
aEvent->mClass == eTouchEventClass ||
aEvent->mClass == eKeyboardEventClass ||
IsMessageGamepadUserActivity(aEvent->mMessage))) {
if (gMouseOrKeyboardEventCounter == 0) {
@@ -571,17 +571,17 @@ EventStateManager::PreHandleEvent(nsPres
if (aEvent->HasDragEventMessage() && sIsPointerLocked) {
NS_ASSERTION(sIsPointerLocked,
"sIsPointerLocked is true. Drag events should be suppressed when "
"the pointer is locked.");
}
#endif
// Store last known screenPoint and clientPoint so pointer lock
// can use these values as constants.
- if (aEvent->mFlags.mIsTrusted &&
+ if (aEvent->IsTrusted() &&
((mouseEvent && mouseEvent->IsReal()) ||
aEvent->mClass == eWheelEventClass) &&
!sIsPointerLocked) {
sLastScreenPoint =
Event::GetScreenCoords(aPresContext, aEvent, aEvent->refPoint);
sLastClientPoint =
Event::GetClientCoords(aPresContext, aEvent, aEvent->refPoint, CSSIntPoint(0, 0));
}
@@ -731,17 +731,17 @@ EventStateManager::PreHandleEvent(nsPres
// Prevent keyboard scrolling while an accesskey modifier is in use.
if (modifierMask &&
(modifierMask == Prefs::ChromeAccessModifierMask() ||
modifierMask == Prefs::ContentAccessModifierMask())) {
AutoTArray<uint32_t, 10> accessCharCodes;
keyEvent->GetAccessKeyCandidates(accessCharCodes);
if (HandleAccessKey(aPresContext, accessCharCodes,
- keyEvent->mFlags.mIsTrusted, modifierMask)) {
+ keyEvent->IsTrusted(), modifierMask)) {
*aStatus = nsEventStatus_eConsumeNoDefault;
}
}
}
// then fall through...
MOZ_FALLTHROUGH;
case eBeforeKeyDown:
case eKeyDown:
@@ -766,17 +766,17 @@ EventStateManager::PreHandleEvent(nsPres
IMEStateManager::GetTextCompositionFor(aPresContext);
aEvent->AsKeyboardEvent()->mIsComposing = !!composition;
}
break;
case eWheel:
case eWheelOperationStart:
case eWheelOperationEnd:
{
- NS_ASSERTION(aEvent->mFlags.mIsTrusted,
+ NS_ASSERTION(aEvent->IsTrusted(),
"Untrusted wheel event shouldn't be here");
nsIContent* content = GetFocusedContent();
if (content) {
mCurrentTargetContent = content;
}
if (aEvent->mMessage != eWheel) {
@@ -811,17 +811,17 @@ EventStateManager::PreHandleEvent(nsPres
case eContentCommandRedo:
case eContentCommandPasteTransferable:
DoContentCommandEvent(aEvent->AsContentCommandEvent());
break;
case eContentCommandScroll:
DoContentCommandScrollEvent(aEvent->AsContentCommandEvent());
break;
case eCompositionStart:
- if (aEvent->mFlags.mIsTrusted) {
+ if (aEvent->IsTrusted()) {
// If the event is trusted event, set the selected text to data of
// composition event.
WidgetCompositionEvent* compositionEvent = aEvent->AsCompositionEvent();
WidgetQueryContentEvent selectedText(true, eQuerySelectedText,
compositionEvent->widget);
HandleQueryContentEvent(&selectedText);
NS_ASSERTION(selectedText.mSucceeded, "Failed to get selected text");
compositionEvent->mData = selectedText.mReply.mString;
@@ -1371,17 +1371,17 @@ EventStateManager::HandleCrossProcessEve
// is a one-shot that will be cancelled when the user moves enough to fire
// a drag.
//
void
EventStateManager::CreateClickHoldTimer(nsPresContext* inPresContext,
nsIFrame* inDownFrame,
WidgetGUIEvent* inMouseDownEvent)
{
- if (!inMouseDownEvent->mFlags.mIsTrusted ||
+ if (!inMouseDownEvent->IsTrusted() ||
IsRemoteTarget(mGestureDownContent) ||
sIsPointerLocked) {
return;
}
// just to be anal (er, safe)
if (mClickHoldTimer) {
mClickHoldTimer->Cancel();
@@ -1729,21 +1729,20 @@ EventStateManager::GenerateDragGesture(n
// Use our targetContent, now that we've determined it, as the
// parent object of the DataTransfer.
dataTransfer->SetParentObject(targetContent);
sLastDragOverFrame = nullptr;
nsCOMPtr<nsIWidget> widget = mCurrentTarget->GetNearestWidget();
// get the widget from the target frame
- WidgetDragEvent startEvent(aEvent->mFlags.mIsTrusted,
- eDragStart, widget);
+ WidgetDragEvent startEvent(aEvent->IsTrusted(), eDragStart, widget);
FillInEventFromGestureDown(&startEvent);
- WidgetDragEvent gestureEvent(aEvent->mFlags.mIsTrusted,
+ WidgetDragEvent gestureEvent(aEvent->IsTrusted(),
eLegacyDragGesture, widget);
FillInEventFromGestureDown(&gestureEvent);
startEvent.dataTransfer = gestureEvent.dataTransfer = dataTransfer;
startEvent.inputSource = gestureEvent.inputSource = aEvent->inputSource;
// Dispatch to the DOM. By setting mCurrentTarget we are faking
// out the ESM and telling it that the current target frame is
@@ -2288,17 +2287,17 @@ EventStateManager::SendLineScrollEvent(n
targetContent = GetFocusedContent();
if (!targetContent)
return;
while (targetContent->IsNodeOfType(nsINode::eTEXT)) {
targetContent = targetContent->GetParent();
}
- WidgetMouseScrollEvent event(aEvent->mFlags.mIsTrusted,
+ WidgetMouseScrollEvent event(aEvent->IsTrusted(),
eLegacyMouseLineOrPageScroll, aEvent->widget);
event.mFlags.mDefaultPrevented = aState.mDefaultPrevented;
event.mFlags.mDefaultPreventedByContent = aState.mDefaultPreventedByContent;
event.refPoint = aEvent->refPoint;
event.widget = aEvent->widget;
event.time = aEvent->time;
event.timeStamp = aEvent->timeStamp;
event.modifiers = aEvent->modifiers;
@@ -2328,17 +2327,17 @@ EventStateManager::SendPixelScrollEvent(
if (!targetContent)
return;
}
while (targetContent->IsNodeOfType(nsINode::eTEXT)) {
targetContent = targetContent->GetParent();
}
- WidgetMouseScrollEvent event(aEvent->mFlags.mIsTrusted,
+ WidgetMouseScrollEvent event(aEvent->IsTrusted(),
eLegacyMousePixelScroll, aEvent->widget);
event.mFlags.mDefaultPrevented = aState.mDefaultPrevented;
event.mFlags.mDefaultPreventedByContent = aState.mDefaultPreventedByContent;
event.refPoint = aEvent->refPoint;
event.widget = aEvent->widget;
event.time = aEvent->time;
event.timeStamp = aEvent->timeStamp;
event.modifiers = aEvent->modifiers;
@@ -3129,31 +3128,31 @@ EventStateManager::PostHandleEvent(nsPre
if (shell) {
RefPtr<nsFrameSelection> frameSelection = shell->FrameSelection();
frameSelection->SetDragState(false);
}
}
break;
case eWheelOperationEnd:
{
- MOZ_ASSERT(aEvent->mFlags.mIsTrusted);
+ MOZ_ASSERT(aEvent->IsTrusted());
ScrollbarsForWheel::MayInactivate();
WidgetWheelEvent* wheelEvent = aEvent->AsWheelEvent();
nsIScrollableFrame* scrollTarget =
do_QueryFrame(ComputeScrollTarget(aTargetFrame, wheelEvent,
COMPUTE_DEFAULT_ACTION_TARGET));
if (scrollTarget) {
scrollTarget->ScrollSnap();
}
}
break;
case eWheel:
case eWheelOperationStart:
{
- MOZ_ASSERT(aEvent->mFlags.mIsTrusted);
+ MOZ_ASSERT(aEvent->IsTrusted());
if (*aStatus == nsEventStatus_eConsumeNoDefault) {
ScrollbarsForWheel::Inactivate();
break;
}
WidgetWheelEvent* wheelEvent = aEvent->AsWheelEvent();
@@ -3422,18 +3421,17 @@ EventStateManager::PostHandleEvent(nsPre
{
// now fire the dragdrop event, for compatibility with XUL
if (mCurrentTarget && nsEventStatus_eConsumeNoDefault != *aStatus) {
nsCOMPtr<nsIContent> targetContent;
mCurrentTarget->GetContentForEvent(aEvent,
getter_AddRefs(targetContent));
nsCOMPtr<nsIWidget> widget = mCurrentTarget->GetNearestWidget();
- WidgetDragEvent event(aEvent->mFlags.mIsTrusted,
- eLegacyDragDrop, widget);
+ WidgetDragEvent event(aEvent->IsTrusted(), eLegacyDragDrop, widget);
WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent();
event.refPoint = mouseEvent->refPoint;
if (mouseEvent->widget) {
event.refPoint += mouseEvent->widget->WidgetToScreenOffset();
}
event.refPoint -= widget->WidgetToScreenOffset();
event.modifiers = mouseEvent->modifiers;
@@ -3849,31 +3847,31 @@ CreateMouseOrPointerWidgetEvent(WidgetMo
{
WidgetPointerEvent* sourcePointer = aMouseEvent->AsPointerEvent();
if (sourcePointer) {
PROFILER_LABEL("Input", "DispatchPointerEvent",
js::ProfileEntry::Category::EVENTS);
nsAutoPtr<WidgetPointerEvent> newPointerEvent;
newPointerEvent =
- new WidgetPointerEvent(aMouseEvent->mFlags.mIsTrusted, aMessage,
+ new WidgetPointerEvent(aMouseEvent->IsTrusted(), aMessage,
aMouseEvent->widget);
newPointerEvent->isPrimary = sourcePointer->isPrimary;
newPointerEvent->pointerId = sourcePointer->pointerId;
newPointerEvent->width = sourcePointer->width;
newPointerEvent->height = sourcePointer->height;
newPointerEvent->inputSource = sourcePointer->inputSource;
newPointerEvent->relatedTarget =
nsIPresShell::GetPointerCapturingContent(sourcePointer->pointerId)
? nullptr
: aRelatedContent;
aNewEvent = newPointerEvent.forget();
} else {
aNewEvent =
- new WidgetMouseEvent(aMouseEvent->mFlags.mIsTrusted, aMessage,
+ new WidgetMouseEvent(aMouseEvent->IsTrusted(), aMessage,
aMouseEvent->widget, WidgetMouseEvent::eReal);
aNewEvent->relatedTarget = aRelatedContent;
}
aNewEvent->refPoint = aMouseEvent->refPoint;
aNewEvent->modifiers = aMouseEvent->modifiers;
aNewEvent->button = aMouseEvent->button;
aNewEvent->buttons = aMouseEvent->buttons;
aNewEvent->pressure = aMouseEvent->pressure;
@@ -4475,18 +4473,17 @@ void
EventStateManager::FireDragEnterOrExit(nsPresContext* aPresContext,
WidgetDragEvent* aDragEvent,
EventMessage aMessage,
nsIContent* aRelatedTarget,
nsIContent* aTargetContent,
nsWeakFrame& aTargetFrame)
{
nsEventStatus status = nsEventStatus_eIgnore;
- WidgetDragEvent event(aDragEvent->mFlags.mIsTrusted, aMessage,
- aDragEvent->widget);
+ WidgetDragEvent event(aDragEvent->IsTrusted(), aMessage, aDragEvent->widget);
event.refPoint = aDragEvent->refPoint;
event.modifiers = aDragEvent->modifiers;
event.buttons = aDragEvent->buttons;
event.relatedTarget = aRelatedTarget;
event.inputSource = aDragEvent->inputSource;
mCurrentTargetContent = aTargetContent;
@@ -4630,17 +4627,17 @@ EventStateManager::CheckForAndDispatchCl
if (aEvent->widget && !aEvent->widget->IsEnabled()) {
return ret;
}
//fire click
bool notDispatchToContents =
(aEvent->button == WidgetMouseEvent::eMiddleButton ||
aEvent->button == WidgetMouseEvent::eRightButton);
- WidgetMouseEvent event(aEvent->mFlags.mIsTrusted, eMouseClick,
+ WidgetMouseEvent event(aEvent->IsTrusted(), eMouseClick,
aEvent->widget, WidgetMouseEvent::eReal);
event.refPoint = aEvent->refPoint;
event.clickCount = aEvent->clickCount;
event.modifiers = aEvent->modifiers;
event.buttons = aEvent->buttons;
event.time = aEvent->time;
event.timeStamp = aEvent->timeStamp;
event.mFlags.mNoContentDispatch = notDispatchToContents;
@@ -4664,17 +4661,17 @@ EventStateManager::CheckForAndDispatchCl
// HandleEvent clears out mCurrentTarget which we might need again
nsWeakFrame currentTarget = mCurrentTarget;
ret = presShell->HandleEventWithTarget(&event, currentTarget,
mouseContent, aStatus);
if (NS_SUCCEEDED(ret) && aEvent->clickCount == 2 &&
mouseContent && mouseContent->IsInComposedDoc()) {
//fire double click
- WidgetMouseEvent event2(aEvent->mFlags.mIsTrusted, eMouseDoubleClick,
+ WidgetMouseEvent event2(aEvent->IsTrusted(), eMouseDoubleClick,
aEvent->widget, WidgetMouseEvent::eReal);
event2.refPoint = aEvent->refPoint;
event2.clickCount = aEvent->clickCount;
event2.modifiers = aEvent->modifiers;
event2.buttons = aEvent->buttons;
event2.mFlags.mNoContentDispatch = notDispatchToContents;
event2.button = aEvent->button;
event2.inputSource = aEvent->inputSource;
@@ -5892,17 +5889,17 @@ AutoHandlingUserInputStatePusher::AutoHa
if (!aIsHandlingUserInput) {
return;
}
EventStateManager::StartHandlingUserInput();
if (mIsMouseDown) {
nsIPresShell::SetCapturingContent(nullptr, 0);
nsIPresShell::AllowMouseCapture(true);
}
- if (!aDocument || !aEvent || !aEvent->mFlags.mIsTrusted) {
+ if (!aDocument || !aEvent || !aEvent->IsTrusted()) {
return;
}
mResetFMMouseButtonHandlingState =
(aEvent->mMessage == eMouseDown || aEvent->mMessage == eMouseUp);
if (mResetFMMouseButtonHandlingState) {
nsFocusManager* fm = nsFocusManager::GetFocusManager();
NS_ENSURE_TRUE_VOID(fm);
// If it's in modal state, mouse button event handling may be nested.
--- a/dom/events/IMEContentObserver.cpp
+++ b/dom/events/IMEContentObserver.cpp
@@ -751,17 +751,17 @@ IMEContentObserver::HandleQueryContentEv
bool
IMEContentObserver::OnMouseButtonEvent(nsPresContext* aPresContext,
WidgetMouseEvent* aMouseEvent)
{
if (!mUpdatePreference.WantMouseButtonEventOnChar()) {
return false;
}
- if (!aMouseEvent->mFlags.mIsTrusted ||
+ if (!aMouseEvent->IsTrusted() ||
aMouseEvent->DefaultPrevented() ||
!aMouseEvent->widget) {
return false;
}
// Now, we need to notify only mouse down and mouse up event.
switch (aMouseEvent->mMessage) {
case eMouseUp:
case eMouseDown:
--- a/dom/events/IMEStateManager.cpp
+++ b/dom/events/IMEStateManager.cpp
@@ -1159,17 +1159,17 @@ IMEStateManager::DispatchCompositionEven
aCompositionEvent->widget.get(),
aCompositionEvent->widget->GetNativeIMEContext().mRawNativeIMEContext,
aCompositionEvent->widget->GetNativeIMEContext().mOriginProcessID,
GetBoolName(aCompositionEvent->widget->Destroyed()),
GetBoolName(aCompositionEvent->mFlags.mIsTrusted),
GetBoolName(aCompositionEvent->mFlags.mPropagationStopped),
GetBoolName(aIsSynthesized), tabParent.get()));
- if (!aCompositionEvent->mFlags.mIsTrusted ||
+ if (!aCompositionEvent->IsTrusted() ||
aCompositionEvent->mFlags.mPropagationStopped) {
return;
}
MOZ_ASSERT(aCompositionEvent->mMessage != eCompositionUpdate,
"compositionupdate event shouldn't be dispatched manually");
EnsureTextCompositionArray();
@@ -1256,17 +1256,17 @@ IMEStateManager::HandleSelectionEvent(ns
("ISM: IMEStateManager::HandleSelectionEvent(aPresContext=0x%p, "
"aEventTargetContent=0x%p, aSelectionEvent={ mMessage=%s, "
"mFlags={ mIsTrusted=%s } }), tabParent=%p",
aPresContext, aEventTargetContent,
ToChar(aSelectionEvent->mMessage),
GetBoolName(aSelectionEvent->mFlags.mIsTrusted),
tabParent.get()));
- if (!aSelectionEvent->mFlags.mIsTrusted) {
+ if (!aSelectionEvent->IsTrusted()) {
return;
}
RefPtr<TextComposition> composition = sTextCompositions ?
sTextCompositions->GetCompositionFor(aSelectionEvent->widget) : nullptr;
if (composition) {
// When there is a composition, TextComposition should guarantee that the
// selection event will be handled in same target as composition events.
@@ -1298,17 +1298,17 @@ IMEStateManager::OnCompositionEventDisca
aCompositionEvent->mNativeIMEContext.mRawNativeIMEContext,
aCompositionEvent->mNativeIMEContext.mOriginProcessID,
aCompositionEvent->widget.get(),
aCompositionEvent->widget->GetNativeIMEContext().mRawNativeIMEContext,
aCompositionEvent->widget->GetNativeIMEContext().mOriginProcessID,
GetBoolName(aCompositionEvent->widget->Destroyed()),
GetBoolName(aCompositionEvent->mFlags.mIsTrusted)));
- if (!aCompositionEvent->mFlags.mIsTrusted) {
+ if (!aCompositionEvent->IsTrusted()) {
return;
}
// Ignore compositionstart for now because sTextCompositions may not have
// been created yet.
if (aCompositionEvent->mMessage == eCompositionStart) {
return;
}
--- a/dom/events/TextComposition.cpp
+++ b/dom/events/TextComposition.cpp
@@ -113,17 +113,17 @@ TextComposition::CloneAndDispatchAs(
nsEventStatus* aStatus,
EventDispatchingCallback* aCallBack)
{
MOZ_RELEASE_ASSERT(!mTabParent);
MOZ_ASSERT(IsValidStateForComposition(aCompositionEvent->widget),
"Should be called only when it's safe to dispatch an event");
- WidgetCompositionEvent compositionEvent(aCompositionEvent->mFlags.mIsTrusted,
+ WidgetCompositionEvent compositionEvent(aCompositionEvent->IsTrusted(),
aMessage, aCompositionEvent->widget);
compositionEvent.time = aCompositionEvent->time;
compositionEvent.timeStamp = aCompositionEvent->timeStamp;
compositionEvent.mData = aCompositionEvent->mData;
compositionEvent.mNativeIMEContext = aCompositionEvent->mNativeIMEContext;
compositionEvent.mOriginalMessage = aCompositionEvent->mMessage;
compositionEvent.mFlags.mIsSynthesizedForTests =
aCompositionEvent->mFlags.mIsSynthesizedForTests;
@@ -154,17 +154,17 @@ TextComposition::DispatchEvent(WidgetCom
void
TextComposition::OnCompositionEventDiscarded(
WidgetCompositionEvent* aCompositionEvent)
{
// Note that this method is never called for synthesized events for emulating
// commit or cancel composition.
- MOZ_ASSERT(aCompositionEvent->mFlags.mIsTrusted,
+ MOZ_ASSERT(aCompositionEvent->IsTrusted(),
"Shouldn't be called with untrusted event");
if (mTabParent) {
// The composition event should be discarded in the child process too.
Unused << mTabParent->SendCompositionEvent(*aCompositionEvent);
}
// XXX If composition events are discarded, should we dispatch them with
--- a/dom/html/HTMLButtonElement.cpp
+++ b/dom/html/HTMLButtonElement.cpp
@@ -287,28 +287,28 @@ HTMLButtonElement::PostHandleEvent(Event
{
// For backwards compat, trigger buttons with space or enter
// (bug 25300)
WidgetKeyboardEvent* keyEvent = aVisitor.mEvent->AsKeyboardEvent();
if ((keyEvent->keyCode == NS_VK_RETURN &&
eKeyPress == aVisitor.mEvent->mMessage) ||
(keyEvent->keyCode == NS_VK_SPACE &&
eKeyUp == aVisitor.mEvent->mMessage)) {
- DispatchSimulatedClick(this, aVisitor.mEvent->mFlags.mIsTrusted,
+ DispatchSimulatedClick(this, aVisitor.mEvent->IsTrusted(),
aVisitor.mPresContext);
aVisitor.mEventStatus = nsEventStatus_eConsumeNoDefault;
}
}
break;
case eMouseDown:
{
WidgetMouseEvent* mouseEvent = aVisitor.mEvent->AsMouseEvent();
if (mouseEvent->button == WidgetMouseEvent::eLeftButton) {
- if (mouseEvent->mFlags.mIsTrusted) {
+ if (mouseEvent->IsTrusted()) {
EventStateManager* esm =
aVisitor.mPresContext->EventStateManager();
EventStateManager::SetActiveManager(
static_cast<EventStateManager*>(esm), this);
}
nsIFocusManager* fm = nsFocusManager::GetFocusManager();
if (fm) {
uint32_t flags = nsIFocusManager::FLAG_BYMOUSE |
--- a/dom/html/HTMLInputElement.cpp
+++ b/dom/html/HTMLInputElement.cpp
@@ -3333,18 +3333,17 @@ HTMLInputElement::PreHandleEvent(EventCh
// Just as nsGenericHTMLFormElementWithState::PreHandleEvent calls
// nsIFormControlFrame::SetFocus, we handle focus here.
nsIFrame* frame = GetPrimaryFrame();
if (frame) {
frame->InvalidateFrameSubtree();
}
}
- if (mType == NS_FORM_INPUT_NUMBER &&
- aVisitor.mEvent->mFlags.mIsTrusted) {
+ if (mType == NS_FORM_INPUT_NUMBER && aVisitor.mEvent->IsTrusted()) {
if (mNumberControlSpinnerIsSpinning) {
// If the timer is running the user has depressed the mouse on one of the
// spin buttons. If the mouse exits the button we either want to reverse
// the direction of spin if it has moved over the other button, or else
// we want to end the spin. We do this here (rather than in
// PostHandleEvent) because we don't want to let content preventDefault()
// the end of the spin.
if (aVisitor.mEvent->mMessage == eMouseMove) {
@@ -3419,17 +3418,17 @@ HTMLInputElement::PreHandleEvent(EventCh
}
}
nsresult rv = nsGenericHTMLFormElementWithState::PreHandleEvent(aVisitor);
// We do this after calling the base class' PreHandleEvent so that
// nsIContent::PreHandleEvent doesn't reset any change we make to mCanHandle.
if (mType == NS_FORM_INPUT_NUMBER &&
- aVisitor.mEvent->mFlags.mIsTrusted &&
+ aVisitor.mEvent->IsTrusted() &&
aVisitor.mEvent->originalTarget != this) {
// <input type=number> has an anonymous <input type=text> descendant. If
// 'input' or 'change' events are fired at that text control then we need
// to do some special handling here.
HTMLInputElement* textControl = nullptr;
nsNumberControlFrame* numberControlFrame =
do_QueryFrame(GetPrimaryFrame());
if (numberControlFrame) {
@@ -3868,17 +3867,17 @@ HTMLInputElement::PostHandleEvent(EventC
#endif
}
}
if (NS_SUCCEEDED(rv)) {
WidgetKeyboardEvent* keyEvent = aVisitor.mEvent->AsKeyboardEvent();
if (mType == NS_FORM_INPUT_NUMBER &&
keyEvent && keyEvent->mMessage == eKeyPress &&
- aVisitor.mEvent->mFlags.mIsTrusted &&
+ aVisitor.mEvent->IsTrusted() &&
(keyEvent->keyCode == NS_VK_UP || keyEvent->keyCode == NS_VK_DOWN) &&
!(keyEvent->IsShift() || keyEvent->IsControl() ||
keyEvent->IsAlt() || keyEvent->IsMeta() ||
keyEvent->IsAltGraph() || keyEvent->IsFn() ||
keyEvent->IsOS())) {
// We handle the up/down arrow keys specially for <input type=number>.
// On some platforms the editor for the nested text control will
// process these keys to send the cursor to the start/end of the text
@@ -3946,17 +3945,17 @@ HTMLInputElement::PostHandleEvent(EventC
MOZ_FALLTHROUGH;
}
case NS_FORM_INPUT_BUTTON:
case NS_FORM_INPUT_RESET:
case NS_FORM_INPUT_SUBMIT:
case NS_FORM_INPUT_IMAGE: // Bug 34418
case NS_FORM_INPUT_COLOR:
{
- DispatchSimulatedClick(this, aVisitor.mEvent->mFlags.mIsTrusted,
+ DispatchSimulatedClick(this, aVisitor.mEvent->IsTrusted(),
aVisitor.mPresContext);
aVisitor.mEventStatus = nsEventStatus_eConsumeNoDefault;
} // case
} // switch
}
if (aVisitor.mEvent->mMessage == eKeyPress &&
mType == NS_FORM_INPUT_RADIO && !keyEvent->IsAlt() &&
!keyEvent->IsControl() && !keyEvent->IsMeta()) {
@@ -3975,17 +3974,17 @@ HTMLInputElement::PostHandleEvent(EventC
GetAttr(kNameSpaceID_None, nsGkAtoms::name, name);
RefPtr<HTMLInputElement> selectedRadioButton;
container->GetNextRadioButton(name, isMovingBack, this,
getter_AddRefs(selectedRadioButton));
if (selectedRadioButton) {
rv = selectedRadioButton->Focus();
if (NS_SUCCEEDED(rv)) {
rv = DispatchSimulatedClick(selectedRadioButton,
- aVisitor.mEvent->mFlags.mIsTrusted,
+ aVisitor.mEvent->IsTrusted(),
aVisitor.mPresContext);
if (NS_SUCCEEDED(rv)) {
aVisitor.mEventStatus = nsEventStatus_eConsumeNoDefault;
}
}
}
}
}
@@ -4087,18 +4086,17 @@ HTMLInputElement::PostHandleEvent(EventC
mType == NS_FORM_INPUT_SUBMIT) {
if (aVisitor.mDOMEvent) {
aVisitor.mDOMEvent->StopPropagation();
} else {
rv = NS_ERROR_FAILURE;
}
}
}
- if (mType == NS_FORM_INPUT_NUMBER &&
- aVisitor.mEvent->mFlags.mIsTrusted) {
+ if (mType == NS_FORM_INPUT_NUMBER && aVisitor.mEvent->IsTrusted()) {
if (mouseEvent->button == WidgetMouseEvent::eLeftButton &&
!(mouseEvent->IsShift() || mouseEvent->IsControl() ||
mouseEvent->IsAlt() || mouseEvent->IsMeta() ||
mouseEvent->IsAltGraph() || mouseEvent->IsFn() ||
mouseEvent->IsOS())) {
nsNumberControlFrame* numberControlFrame =
do_QueryFrame(GetPrimaryFrame());
if (numberControlFrame) {
--- a/dom/html/HTMLObjectElement.cpp
+++ b/dom/html/HTMLObjectElement.cpp
@@ -207,17 +207,17 @@ HTMLObjectElement::HandlePluginInstantia
OnFocusBlurPlugin(aElement, true);
}
}
void
HTMLObjectElement::HandleFocusBlurPlugin(Element* aElement,
WidgetEvent* aEvent)
{
- if (!aEvent->mFlags.mIsTrusted) {
+ if (!aEvent->IsTrusted()) {
return;
}
switch (aEvent->mMessage) {
case eFocus: {
OnFocusBlurPlugin(aElement, true);
break;
}
case eBlur: {
--- a/dom/html/nsGenericHTMLElement.cpp
+++ b/dom/html/nsGenericHTMLElement.cpp
@@ -2269,17 +2269,17 @@ nsGenericHTMLFormElement::AfterSetAttr(i
return nsGenericHTMLElement::AfterSetAttr(aNameSpaceID, aName,
aValue, aNotify);
}
nsresult
nsGenericHTMLFormElement::PreHandleEvent(EventChainPreVisitor& aVisitor)
{
- if (aVisitor.mEvent->mFlags.mIsTrusted) {
+ if (aVisitor.mEvent->IsTrusted()) {
switch (aVisitor.mEvent->mMessage) {
case eFocus: {
// Check to see if focus has bubbled up from a form control's
// child textfield or button. If that's the case, don't focus
// this parent file control -- leave focus on the child.
nsIFormControlFrame* formControlFrame = GetFormControlFrame(true);
if (formControlFrame &&
aVisitor.mEvent->originalTarget == static_cast<nsINode*>(this))
--- a/dom/plugins/base/nsPluginInstanceOwner.cpp
+++ b/dom/plugins/base/nsPluginInstanceOwner.cpp
@@ -1682,17 +1682,17 @@ nsresult nsPluginInstanceOwner::Dispatch
if (!mPluginWindow || (mPluginWindow->type == NPWindowTypeWindow)) {
// continue only for cases without child window
return aFocusEvent->PreventDefault(); // consume event
}
#endif
WidgetEvent* theEvent = aFocusEvent->WidgetEventPtr();
if (theEvent) {
- WidgetGUIEvent focusEvent(theEvent->mFlags.mIsTrusted, theEvent->mMessage,
+ WidgetGUIEvent focusEvent(theEvent->IsTrusted(), theEvent->mMessage,
nullptr);
nsEventStatus rv = ProcessEvent(focusEvent);
if (nsEventStatus_eConsumeNoDefault == rv) {
aFocusEvent->PreventDefault();
aFocusEvent->StopPropagation();
}
}
@@ -2041,17 +2041,17 @@ nsPluginInstanceOwner::HandleEvent(nsIDO
eventType.EqualsLiteral("compositionend") ||
eventType.EqualsLiteral("text")) {
return DispatchCompositionToPlugin(aEvent);
}
nsCOMPtr<nsIDOMDragEvent> dragEvent(do_QueryInterface(aEvent));
if (dragEvent && mInstance) {
WidgetEvent* ievent = aEvent->WidgetEventPtr();
- if (ievent && ievent->mFlags.mIsTrusted &&
+ if (ievent && ievent->IsTrusted() &&
ievent->mMessage != eDragEnter && ievent->mMessage != eDragOver) {
aEvent->PreventDefault();
}
// Let the plugin handle drag events.
aEvent->StopPropagation();
}
return NS_OK;
--- a/dom/xbl/nsXBLEventHandler.cpp
+++ b/dom/xbl/nsXBLEventHandler.cpp
@@ -92,17 +92,17 @@ nsXBLKeyEventHandler::ExecuteMatchedHand
{
WidgetEvent* event = aKeyEvent->AsEvent()->WidgetEventPtr();
nsCOMPtr<EventTarget> target = aKeyEvent->AsEvent()->InternalDOMEvent()->GetCurrentTarget();
bool executed = false;
for (uint32_t i = 0; i < mProtoHandlers.Length(); ++i) {
nsXBLPrototypeHandler* handler = mProtoHandlers[i];
bool hasAllowUntrustedAttr = handler->HasAllowUntrustedAttr();
- if ((event->mFlags.mIsTrusted ||
+ if ((event->IsTrusted() ||
(hasAllowUntrustedAttr && handler->AllowUntrustedEvents()) ||
(!hasAllowUntrustedAttr && !mIsBoundToChrome && !mUsingContentXBLScope)) &&
handler->KeyEventMatched(aKeyEvent, aCharCode, aIgnoreModifierState)) {
handler->ExecuteHandler(target, aKeyEvent->AsEvent());
executed = true;
}
}
#ifdef XP_WIN
--- a/dom/xul/nsXULElement.cpp
+++ b/dom/xul/nsXULElement.cpp
@@ -1327,17 +1327,17 @@ nsXULElement::PreHandleEvent(EventChainP
} else {
domEvent = nullptr;
}
}
WidgetInputEvent* orig = aVisitor.mEvent->AsInputEvent();
nsContentUtils::DispatchXULCommand(
commandContent,
- aVisitor.mEvent->mFlags.mIsTrusted,
+ aVisitor.mEvent->IsTrusted(),
aVisitor.mDOMEvent,
nullptr,
orig->IsControl(),
orig->IsAlt(),
orig->IsShift(),
orig->IsMeta());
} else {
NS_WARNING("A XUL element is attached to a command that doesn't exist!\n");
--- a/editor/libeditor/nsEditor.cpp
+++ b/editor/libeditor/nsEditor.cpp
@@ -5097,17 +5097,17 @@ nsEditor::IsAcceptableInputEvent(nsIDOME
break;
}
if (needsWidget &&
(!widgetGUIEvent || !widgetGUIEvent->widget)) {
return false;
}
// Accept all trusted events.
- if (widgetEvent->mFlags.mIsTrusted) {
+ if (widgetEvent->IsTrusted()) {
return true;
}
// Ignore untrusted mouse event.
// XXX Why are we handling other untrusted input events?
if (widgetEvent->AsMouseEventBase()) {
return false;
}
--- a/layout/base/nsPresShell.cpp
+++ b/layout/base/nsPresShell.cpp
@@ -6826,17 +6826,18 @@ DispatchPointerFromMouseOrTouch(PresShel
}
for (uint32_t i = 0; i < touchEvent->touches.Length(); ++i) {
mozilla::dom::Touch* touch = touchEvent->touches[i];
if (!touch || !touch->convertToPointer) {
continue;
}
- WidgetPointerEvent event(touchEvent->mFlags.mIsTrusted, pointerMessage, touchEvent->widget);
+ WidgetPointerEvent event(touchEvent->IsTrusted(), pointerMessage,
+ touchEvent->widget);
event.isPrimary = i == 0;
event.pointerId = touch->Identifier();
event.refPoint = touch->mRefPoint;
event.modifiers = touchEvent->modifiers;
event.width = touch->RadiusX();
event.height = touch->RadiusY();
event.tiltX = touch->tiltX;
event.tiltY = touch->tiltY;
@@ -6961,17 +6962,17 @@ PresShell::DispatchBeforeKeyboardEventIn
// Dispatch before events from the outermost element.
for (int32_t i = length - 1; i >= 0; i--) {
eventTarget = do_QueryInterface(aChain[i]->OwnerDoc()->GetWindow());
if (!eventTarget || !CanDispatchEvent(&aEvent)) {
return;
}
aChainIndex = i;
- InternalBeforeAfterKeyboardEvent beforeEvent(aEvent.mFlags.mIsTrusted,
+ InternalBeforeAfterKeyboardEvent beforeEvent(aEvent.IsTrusted(),
message, aEvent.widget);
beforeEvent.AssignBeforeAfterKeyEventData(aEvent, false);
EventDispatcher::Dispatch(eventTarget, mPresContext, &beforeEvent);
if (beforeEvent.DefaultPrevented()) {
aDefaultPrevented = true;
return;
}
@@ -6995,17 +6996,17 @@ PresShell::DispatchAfterKeyboardEventInt
nsCOMPtr<EventTarget> eventTarget;
// Dispatch after events from the innermost element.
for (uint32_t i = aStartOffset; i < length; i++) {
eventTarget = do_QueryInterface(aChain[i]->OwnerDoc()->GetWindow());
if (!eventTarget || !CanDispatchEvent(&aEvent)) {
return;
}
- InternalBeforeAfterKeyboardEvent afterEvent(aEvent.mFlags.mIsTrusted,
+ InternalBeforeAfterKeyboardEvent afterEvent(aEvent.IsTrusted(),
message, aEvent.widget);
afterEvent.AssignBeforeAfterKeyEventData(aEvent, false);
afterEvent.mEmbeddedCancelled.SetValue(embeddedCancelled);
EventDispatcher::Dispatch(eventTarget, mPresContext, &afterEvent);
embeddedCancelled = afterEvent.DefaultPrevented();
}
}
@@ -7912,17 +7913,17 @@ PresShell::HandleEventInternal(WidgetEve
RefPtr<EventStateManager> manager = mPresContext->EventStateManager();
nsresult rv = NS_OK;
if (!NS_EVENT_NEEDS_FRAME(aEvent) || GetCurrentEventFrame() || GetCurrentEventContent()) {
bool touchIsNew = false;
bool isHandlingUserInput = false;
// XXX How about IME events and input events for plugins?
- if (aEvent->mFlags.mIsTrusted) {
+ if (aEvent->IsTrusted()) {
switch (aEvent->mMessage) {
case eKeyPress:
case eKeyDown:
case eKeyUp: {
nsIDocument* doc = GetCurrentEventContent() ?
mCurrentEventContent->OwnerDoc() : nullptr;
auto keyCode = aEvent->AsKeyboardEvent()->keyCode;
if (keyCode == NS_VK_ESCAPE) {
@@ -8012,17 +8013,17 @@ PresShell::HandleEventInternal(WidgetEve
aEvent->mFlags.mOnlyChromeDispatch = true;
aEvent->mFlags.mRetargetToNonNativeAnonymous = true;
}
}
AutoHandlingUserInputStatePusher userInpStatePusher(isHandlingUserInput,
aEvent, mDocument);
- if (aEvent->mFlags.mIsTrusted && aEvent->mMessage == eMouseMove) {
+ if (aEvent->IsTrusted() && aEvent->mMessage == eMouseMove) {
nsIPresShell::AllowMouseCapture(
EventStateManager::GetActiveEventStateManager() == manager);
}
nsAutoPopupStatePusher popupStatePusher(
Event::GetEventPopupControlState(aEvent));
// FIXME. If the event was reused, we need to clear the old target,
@@ -8211,17 +8212,17 @@ PresShell::DispatchTouchEventToDOM(Widge
if (capturingContent) {
if (capturingContent->OwnerDoc() != doc) {
// Wrong document, don't dispatch anything.
continue;
}
content = capturingContent;
}
// copy the event
- WidgetTouchEvent newEvent(touchEvent->mFlags.mIsTrusted,
+ WidgetTouchEvent newEvent(touchEvent->IsTrusted(),
touchEvent->mMessage, touchEvent->widget);
newEvent.AssignTouchEventData(*touchEvent, false);
newEvent.target = targetPtr;
RefPtr<PresShell> contentPresShell;
if (doc == mDocument) {
contentPresShell = static_cast<PresShell*>(doc->GetShell());
if (contentPresShell) {
@@ -9668,30 +9669,30 @@ PresShell::DelayedInputEvent::Dispatch()
nsEventStatus status;
widget->DispatchEvent(mEvent, status);
}
PresShell::DelayedMouseEvent::DelayedMouseEvent(WidgetMouseEvent* aEvent) :
DelayedInputEvent()
{
WidgetMouseEvent* mouseEvent =
- new WidgetMouseEvent(aEvent->mFlags.mIsTrusted,
+ new WidgetMouseEvent(aEvent->IsTrusted(),
aEvent->mMessage,
aEvent->widget,
aEvent->reason,
aEvent->context);
mouseEvent->AssignMouseEventData(*aEvent, false);
mEvent = mouseEvent;
}
PresShell::DelayedKeyEvent::DelayedKeyEvent(WidgetKeyboardEvent* aEvent) :
DelayedInputEvent()
{
WidgetKeyboardEvent* keyEvent =
- new WidgetKeyboardEvent(aEvent->mFlags.mIsTrusted,
+ new WidgetKeyboardEvent(aEvent->IsTrusted(),
aEvent->mMessage,
aEvent->widget);
keyEvent->AssignKeyEventData(*aEvent, false);
keyEvent->mFlags.mIsSynthesizedForTests = aEvent->mFlags.mIsSynthesizedForTests;
mEvent = keyEvent;
}
// Start of DEBUG only code
--- a/layout/xul/nsButtonBoxFrame.cpp
+++ b/layout/xul/nsButtonBoxFrame.cpp
@@ -218,13 +218,13 @@ nsButtonBoxFrame::DoMouseClick(WidgetGUI
isMeta = inputEvent->IsMeta();
}
// Have the content handle the event, propagating it according to normal DOM rules.
nsCOMPtr<nsIPresShell> shell = PresContext()->GetPresShell();
if (shell) {
nsContentUtils::DispatchXULCommand(mContent,
aEvent ?
- aEvent->mFlags.mIsTrusted : aTrustEvent,
+ aEvent->IsTrusted() : aTrustEvent,
nullptr, shell,
isControl, isAlt, isShift, isMeta);
}
}
--- a/layout/xul/nsMenuFrame.cpp
+++ b/layout/xul/nsMenuFrame.cpp
@@ -1227,17 +1227,17 @@ nsMenuFrame::StopBlinking()
}
void
nsMenuFrame::CreateMenuCommandEvent(WidgetGUIEvent* aEvent, bool aFlipChecked)
{
// Create a trusted event if the triggering event was trusted, or if
// we're called from chrome code (since at least one of our caller
// passes in a null event).
- bool isTrusted = aEvent ? aEvent->mFlags.mIsTrusted :
+ bool isTrusted = aEvent ? aEvent->IsTrusted() :
nsContentUtils::IsCallerChrome();
bool shift = false, control = false, alt = false, meta = false;
WidgetInputEvent* inputEvent = aEvent ? aEvent->AsInputEvent() : nullptr;
if (inputEvent) {
shift = inputEvent->IsShift();
control = inputEvent->IsControl();
alt = inputEvent->IsAlt();
--- a/layout/xul/nsResizerFrame.cpp
+++ b/layout/xul/nsResizerFrame.cpp
@@ -534,11 +534,10 @@ nsResizerFrame::GetDirection()
return directions[index];
}
void
nsResizerFrame::MouseClicked(WidgetMouseEvent* aEvent)
{
// Execute the oncommand event handler.
- nsContentUtils::DispatchXULCommand(mContent,
- aEvent && aEvent->mFlags.mIsTrusted);
+ nsContentUtils::DispatchXULCommand(mContent, aEvent && aEvent->IsTrusted());
}
--- a/layout/xul/nsScrollBoxFrame.cpp
+++ b/layout/xul/nsScrollBoxFrame.cpp
@@ -86,17 +86,17 @@ nsAutoRepeatBoxFrame::HandleEvent(nsPres
switch(aEvent->mMessage) {
// repeat mode may be "hover" for repeating while the mouse is hovering
// over the element, otherwise repetition is done while the element is
// active (pressed).
case eMouseEnterIntoWidget:
case eMouseOver:
if (IsActivatedOnHover()) {
StartRepeat();
- mTrustedEvent = aEvent->mFlags.mIsTrusted;
+ mTrustedEvent = aEvent->IsTrusted();
}
break;
case eMouseExitFromWidget:
case eMouseOut:
// always stop on mouse exit
StopRepeat();
// Not really necessary but do this to be safe
@@ -121,17 +121,17 @@ nsAutoRepeatBoxFrame::HandleEvent(nsPres
NS_IMETHODIMP
nsAutoRepeatBoxFrame::HandlePress(nsPresContext* aPresContext,
WidgetGUIEvent* aEvent,
nsEventStatus* aEventStatus)
{
if (!IsActivatedOnHover()) {
StartRepeat();
- mTrustedEvent = aEvent->mFlags.mIsTrusted;
+ mTrustedEvent = aEvent->IsTrusted();
DoMouseClick(aEvent, mTrustedEvent);
}
return NS_OK;
}
NS_IMETHODIMP
nsAutoRepeatBoxFrame::HandleRelease(nsPresContext* aPresContext,
--- a/layout/xul/nsTitleBarFrame.cpp
+++ b/layout/xul/nsTitleBarFrame.cpp
@@ -164,11 +164,10 @@ nsTitleBarFrame::HandleEvent(nsPresConte
else
return NS_OK;
}
void
nsTitleBarFrame::MouseClicked(WidgetMouseEvent* aEvent)
{
// Execute the oncommand event handler.
- nsContentUtils::DispatchXULCommand(mContent,
- aEvent && aEvent->mFlags.mIsTrusted);
+ nsContentUtils::DispatchXULCommand(mContent, aEvent && aEvent->IsTrusted());
}
--- a/widget/BasicEvents.h
+++ b/widget/BasicEvents.h
@@ -168,16 +168,20 @@ public:
{
return mDefaultPrevented;
}
inline bool DefaultPreventedByContent() const
{
MOZ_ASSERT(!mDefaultPreventedByContent || DefaultPrevented());
return mDefaultPreventedByContent;
}
+ inline bool IsTrusted() const
+ {
+ return mIsTrusted;
+ }
inline void Clear()
{
SetRawFlags(0);
}
// Get if either the instance's bit or the aOther's bit is true, the
// instance's bit becomes true. In other words, this works like:
// eventFlags |= aOther;
@@ -363,16 +367,17 @@ public:
mFlags.PreventDefault(aCalledByDefaultHandler);
}
void PreventDefaultBeforeDispatch() { mFlags.PreventDefaultBeforeDispatch(); }
bool DefaultPrevented() const { return mFlags.DefaultPrevented(); }
bool DefaultPreventedByContent() const
{
return mFlags.DefaultPreventedByContent();
}
+ bool IsTrusted() const { return mFlags.IsTrusted(); }
/**
* Utils for checking event types
*/
/**
* As*Event() returns the pointer of the instance only when the instance is
* the class or one of its derived class.
@@ -844,17 +849,17 @@ public:
* aEventCausesThisEvent should be the event. If there is no such event,
* this should be nullptr.
*/
InternalUIEvent(bool aIsTrusted, EventMessage aMessage,
const WidgetEvent* aEventCausesThisEvent)
: WidgetGUIEvent(aIsTrusted, aMessage, nullptr, eUIEventClass)
, detail(0)
, mCausedByUntrustedEvent(
- aEventCausesThisEvent && !aEventCausesThisEvent->mFlags.mIsTrusted)
+ aEventCausesThisEvent && !aEventCausesThisEvent->IsTrusted())
{
}
virtual WidgetEvent* Duplicate() const override
{
MOZ_ASSERT(mClass == eUIEventClass,
"Duplicate() must be overridden by sub class");
InternalUIEvent* result = new InternalUIEvent(false, mMessage, nullptr);
@@ -866,17 +871,17 @@ public:
int32_t detail;
// mCausedByUntrustedEvent is true if the event is caused by untrusted event.
bool mCausedByUntrustedEvent;
// If you check the event is a trusted event and NOT caused by an untrusted
// event, IsTrustable() returns what you expected.
bool IsTrustable() const
{
- return mFlags.mIsTrusted && !mCausedByUntrustedEvent;
+ return IsTrusted() && !mCausedByUntrustedEvent;
}
void AssignUIEventData(const InternalUIEvent& aEvent, bool aCopyTargets)
{
AssignGUIEventData(aEvent, aCopyTargets);
detail = aEvent.detail;
mCausedByUntrustedEvent = aEvent.mCausedByUntrustedEvent;
--- a/widget/TouchEvents.h
+++ b/widget/TouchEvents.h
@@ -101,17 +101,17 @@ public:
, allowedDirections(0)
, direction(0)
, delta(0.0)
, clickCount(0)
{
}
WidgetSimpleGestureEvent(const WidgetSimpleGestureEvent& aOther)
- : WidgetMouseEventBase(aOther.mFlags.mIsTrusted, aOther.mMessage,
+ : WidgetMouseEventBase(aOther.IsTrusted(), aOther.mMessage,
aOther.widget, eSimpleGestureEventClass)
, allowedDirections(aOther.allowedDirections)
, direction(aOther.direction)
, delta(aOther.delta)
, clickCount(0)
{
}
@@ -162,17 +162,17 @@ public:
virtual WidgetTouchEvent* AsTouchEvent() override { return this; }
WidgetTouchEvent()
{
MOZ_COUNT_CTOR(WidgetTouchEvent);
}
WidgetTouchEvent(const WidgetTouchEvent& aOther)
- : WidgetInputEvent(aOther.mFlags.mIsTrusted, aOther.mMessage, aOther.widget,
+ : WidgetInputEvent(aOther.IsTrusted(), aOther.mMessage, aOther.widget,
eTouchEventClass)
{
MOZ_COUNT_CTOR(WidgetTouchEvent);
modifiers = aOther.modifiers;
time = aOther.time;
timeStamp = aOther.timeStamp;
touches.AppendElements(aOther.touches);
mFlags.mCancelable = mMessage != eTouchCancel;