Bug 1259656 part.5 Rename WidgetEvent::target to WidgetEvent::mTarget r?smaug
MozReview-Commit-ID: L0GnVR6NcAe
--- a/dom/base/FragmentOrElement.cpp
+++ b/dom/base/FragmentOrElement.cpp
@@ -878,17 +878,17 @@ nsIContent::PreHandleEvent(EventChainPre
nsCOMPtr<nsIContent> t = do_QueryInterface(aVisitor.mEvent->originalTarget);
NS_ASSERTION(!t || !t->ChromeOnlyAccess() ||
aVisitor.mEvent->mClass != eMutationEventClass ||
aVisitor.mDOMEvent,
"Mutation event dispatched in native anonymous content!?!");
#endif
aVisitor.mEventTargetAtParent = parent;
} else if (parent && aVisitor.mOriginalTargetIsInAnon) {
- nsCOMPtr<nsIContent> content(do_QueryInterface(aVisitor.mEvent->target));
+ nsCOMPtr<nsIContent> content(do_QueryInterface(aVisitor.mEvent->mTarget));
if (content && content->GetBindingParent() == parent) {
aVisitor.mEventTargetAtParent = parent;
}
}
// check for an anonymous parent
// XXX XBL2/sXBL issue
if (HasFlag(NODE_MAY_BE_IN_BINDING_MNGR)) {
--- a/dom/base/nsContentUtils.cpp
+++ b/dom/base/nsContentUtils.cpp
@@ -5280,30 +5280,30 @@ nsContentUtils::SetDataTransferInEvent(W
return NS_ERROR_FAILURE;
}
} else {
// A dataTransfer won't exist when a drag was started by some other
// means, for instance calling the drag service directly, or a drag
// from another application. In either case, a new dataTransfer should
// be created that reflects the data.
initialDataTransfer =
- new DataTransfer(aDragEvent->target, aDragEvent->mMessage, true, -1);
+ new DataTransfer(aDragEvent->mTarget, aDragEvent->mMessage, true, -1);
// now set it in the drag session so we don't need to create it again
dragSession->SetDataTransfer(initialDataTransfer);
}
bool isCrossDomainSubFrameDrop = false;
if (aDragEvent->mMessage == eDrop ||
aDragEvent->mMessage == eLegacyDragDrop) {
isCrossDomainSubFrameDrop = CheckForSubFrameDrop(dragSession, aDragEvent);
}
// each event should use a clone of the original dataTransfer.
- initialDataTransfer->Clone(aDragEvent->target, aDragEvent->mMessage,
+ initialDataTransfer->Clone(aDragEvent->mTarget, aDragEvent->mMessage,
aDragEvent->mUserCancelled,
isCrossDomainSubFrameDrop,
getter_AddRefs(aDragEvent->mDataTransfer));
if (NS_WARN_IF(!aDragEvent->mDataTransfer)) {
return NS_ERROR_OUT_OF_MEMORY;
}
// for the dragenter and dragover events, initialize the drop effect
--- a/dom/events/Event.cpp
+++ b/dom/events/Event.cpp
@@ -148,17 +148,17 @@ NS_IMPL_CYCLE_COLLECTING_RELEASE(Event)
NS_IMPL_CYCLE_COLLECTION_CLASS(Event)
NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(Event)
NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER
NS_IMPL_CYCLE_COLLECTION_TRACE_END
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(Event)
if (tmp->mEventIsInternal) {
- tmp->mEvent->target = nullptr;
+ tmp->mEvent->mTarget = nullptr;
tmp->mEvent->currentTarget = nullptr;
tmp->mEvent->originalTarget = nullptr;
switch (tmp->mEvent->mClass) {
case eMouseEventClass:
case eMouseScrollEventClass:
case eWheelEventClass:
case eSimpleGestureEventClass:
case ePointerEventClass:
@@ -186,17 +186,17 @@ NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(Ev
NS_IMPL_CYCLE_COLLECTION_UNLINK(mPresContext);
NS_IMPL_CYCLE_COLLECTION_UNLINK(mExplicitOriginalTarget);
NS_IMPL_CYCLE_COLLECTION_UNLINK(mOwner);
NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(Event)
if (tmp->mEventIsInternal) {
- NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mEvent->target)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mEvent->mTarget)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mEvent->currentTarget)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mEvent->originalTarget)
switch (tmp->mEvent->mClass) {
case eMouseEventClass:
case eMouseScrollEventClass:
case eWheelEventClass:
case eSimpleGestureEventClass:
case ePointerEventClass:
@@ -283,17 +283,17 @@ static EventTarget*
GetDOMEventTarget(nsIDOMEventTarget* aTarget)
{
return aTarget ? aTarget->GetTargetForDOMEvent() : nullptr;
}
EventTarget*
Event::GetTarget() const
{
- return GetDOMEventTarget(mEvent->target);
+ return GetDOMEventTarget(mEvent->mTarget);
}
NS_METHOD
Event::GetTarget(nsIDOMEventTarget** aTarget)
{
NS_IF_ADDREF(*aTarget = GetTarget());
return NS_OK;
}
@@ -314,17 +314,17 @@ Event::GetCurrentTarget(nsIDOMEventTarge
//
// Get the actual event target node (may have been retargeted for mouse events)
//
already_AddRefed<nsIContent>
Event::GetTargetFromFrame()
{
if (!mPresContext) { return nullptr; }
- // Get the target frame (have to get the ESM first)
+ // Get the mTarget frame (have to get the ESM first)
nsIFrame* targetFrame = mPresContext->EventStateManager()->GetEventTarget();
if (!targetFrame) { return nullptr; }
// get the real content
nsCOMPtr<nsIContent> realEventContent;
targetFrame->GetContentForEvent(mEvent, getter_AddRefs(realEventContent));
return realEventContent.forget();
}
@@ -419,17 +419,17 @@ Event::Constructor(const GlobalObject& a
}
uint16_t
Event::EventPhase() const
{
// Note, remember to check that this works also
// if or when Bug 235441 is fixed.
if ((mEvent->currentTarget &&
- mEvent->currentTarget == mEvent->target) ||
+ mEvent->currentTarget == mEvent->mTarget) ||
mEvent->mFlags.InTargetPhase()) {
return nsIDOMEvent::AT_TARGET;
}
if (mEvent->mFlags.mInCapturePhase) {
return nsIDOMEvent::CAPTURING_PHASE;
}
if (mEvent->mFlags.mInBubblingPhase) {
return nsIDOMEvent::BUBBLING_PHASE;
@@ -581,17 +581,17 @@ Event::InitEvent(const nsAString& aEvent
mEvent->mFlags.mCancelable = aCancelableArg;
mEvent->mFlags.mDefaultPrevented = false;
mEvent->mFlags.mDefaultPreventedByContent = false;
mEvent->mFlags.mDefaultPreventedByChrome = false;
// Clearing the old targets, so that the event is targeted correctly when
// re-dispatching it.
- mEvent->target = nullptr;
+ mEvent->mTarget = nullptr;
mEvent->originalTarget = nullptr;
}
NS_IMETHODIMP
Event::DuplicatePrivateData()
{
NS_ASSERTION(mEvent, "No WidgetEvent for Event duplication!");
if (mEventIsInternal) {
@@ -604,17 +604,17 @@ Event::DuplicatePrivateData()
mPrivateDataDuplicated = true;
return NS_OK;
}
NS_IMETHODIMP
Event::SetTarget(nsIDOMEventTarget* aTarget)
{
- mEvent->target = do_QueryInterface(aTarget);
+ mEvent->mTarget = do_QueryInterface(aTarget);
return NS_OK;
}
NS_IMETHODIMP_(bool)
Event::IsDispatchStopped()
{
return mEvent->PropagationStopped();
}
@@ -986,20 +986,20 @@ Event::GetClientCoords(nsPresContext* aP
// static
CSSIntPoint
Event::GetOffsetCoords(nsPresContext* aPresContext,
WidgetEvent* aEvent,
LayoutDeviceIntPoint aPoint,
CSSIntPoint aDefaultPoint)
{
- if (!aEvent->target) {
+ if (!aEvent->mTarget) {
return GetPageCoords(aPresContext, aEvent, aPoint, aDefaultPoint);
}
- nsCOMPtr<nsIContent> content = do_QueryInterface(aEvent->target);
+ nsCOMPtr<nsIContent> content = do_QueryInterface(aEvent->mTarget);
if (!content || !aPresContext) {
return CSSIntPoint(0, 0);
}
nsCOMPtr<nsIPresShell> shell = aPresContext->GetPresShell();
if (!shell) {
return CSSIntPoint(0, 0);
}
shell->FlushPendingNotifications(Flush_Layout);
--- a/dom/events/EventDispatcher.cpp
+++ b/dom/events/EventDispatcher.cpp
@@ -328,17 +328,17 @@ EventTargetChainItem::PostHandleEvent(Ev
void
EventTargetChainItem::HandleEventTargetChain(
nsTArray<EventTargetChainItem>& aChain,
EventChainPostVisitor& aVisitor,
EventDispatchingCallback* aCallback,
ELMCreationDetector& aCd)
{
// Save the target so that it can be restored later.
- nsCOMPtr<EventTarget> firstTarget = aVisitor.mEvent->target;
+ nsCOMPtr<EventTarget> firstTarget = aVisitor.mEvent->mTarget;
uint32_t chainLength = aChain.Length();
// Capture
aVisitor.mEvent->mFlags.mInCapturePhase = true;
aVisitor.mEvent->mFlags.mInBubblingPhase = false;
for (uint32_t i = chainLength - 1; i > 0; --i) {
EventTargetChainItem& item = aChain[i];
if ((!aVisitor.mEvent->mFlags.mNoContentDispatch ||
@@ -348,17 +348,17 @@ EventTargetChainItem::HandleEventTargetC
}
if (item.GetNewTarget()) {
// item is at anonymous boundary. Need to retarget for the child items.
for (uint32_t j = i; j > 0; --j) {
uint32_t childIndex = j - 1;
EventTarget* newTarget = aChain[childIndex].GetNewTarget();
if (newTarget) {
- aVisitor.mEvent->target = newTarget;
+ aVisitor.mEvent->mTarget = newTarget;
break;
}
}
}
}
// Target
aVisitor.mEvent->mFlags.mInBubblingPhase = true;
@@ -375,17 +375,17 @@ EventTargetChainItem::HandleEventTargetC
// Bubble
aVisitor.mEvent->mFlags.mInCapturePhase = false;
for (uint32_t i = 1; i < chainLength; ++i) {
EventTargetChainItem& item = aChain[i];
EventTarget* newTarget = item.GetNewTarget();
if (newTarget) {
// Item is at anonymous boundary. Need to retarget for the current item
// and for parent items.
- aVisitor.mEvent->target = newTarget;
+ aVisitor.mEvent->mTarget = newTarget;
}
if (aVisitor.mEvent->mFlags.mBubbles || newTarget) {
if ((!aVisitor.mEvent->mFlags.mNoContentDispatch ||
item.ForceContentDispatch()) &&
!aVisitor.mEvent->PropagationStopped()) {
item.HandleEvent(aVisitor, aCd);
}
@@ -398,27 +398,27 @@ EventTargetChainItem::HandleEventTargetC
if (!aVisitor.mEvent->mFlags.mInSystemGroup) {
// Dispatch to the system event group. Make sure to clear the
// STOP_DISPATCH flag since this resets for each event group.
aVisitor.mEvent->mFlags.mPropagationStopped = false;
aVisitor.mEvent->mFlags.mImmediatePropagationStopped = false;
// Setting back the original target of the event.
- aVisitor.mEvent->target = aVisitor.mEvent->originalTarget;
+ aVisitor.mEvent->mTarget = aVisitor.mEvent->originalTarget;
// Special handling if PresShell (or some other caller)
// used a callback object.
if (aCallback) {
aCallback->HandleEvent(aVisitor);
}
// Retarget for system event group (which does the default handling too).
// Setting back the target which was used also for default event group.
- aVisitor.mEvent->target = firstTarget;
+ aVisitor.mEvent->mTarget = firstTarget;
aVisitor.mEvent->mFlags.mInSystemGroup = true;
HandleEventTargetChain(aChain,
aVisitor,
aCallback,
aCd);
aVisitor.mEvent->mFlags.mInSystemGroup = false;
// After dispatch, clear all the propagation flags so that
@@ -527,17 +527,17 @@ EventDispatcher::Dispatch(nsISupports* a
nsPIDOMWindowInner* win = doc->GetInnerWindow();
// If we can't dispatch the event to chrome, do nothing.
EventTarget* piTarget = win ? win->GetParentTarget() : nullptr;
if (!piTarget) {
return NS_OK;
}
// Set the target to be the original dispatch target,
- aEvent->target = target;
+ aEvent->mTarget = target;
// but use chrome event handler or TabChildGlobal for event target chain.
target = piTarget;
} else if (NS_WARN_IF(!doc)) {
return NS_ERROR_UNEXPECTED;
}
}
#ifdef DEBUG
@@ -585,37 +585,37 @@ EventDispatcher::Dispatch(nsISupports* a
MOZ_ASSERT(&chain[0] == targetEtci);
if (!targetEtci->IsValid()) {
EventTargetChainItem::DestroyLast(chain, targetEtci);
return NS_ERROR_FAILURE;
}
// Make sure that nsIDOMEvent::target and nsIDOMEvent::originalTarget
// point to the last item in the chain.
- if (!aEvent->target) {
+ if (!aEvent->mTarget) {
// Note, CurrentTarget() points always to the object returned by
// GetTargetForEventTargetChain().
- aEvent->target = targetEtci->CurrentTarget();
+ aEvent->mTarget = targetEtci->CurrentTarget();
} else {
// XXX But if the target is already set, use that. This is a hack
// for the 'load', 'beforeunload' and 'unload' events,
// which are dispatched to |window| but have document as their target.
//
// Make sure that the event target points to the right object.
- aEvent->target = aEvent->target->GetTargetForEventTargetChain();
- NS_ENSURE_STATE(aEvent->target);
+ aEvent->mTarget = aEvent->mTarget->GetTargetForEventTargetChain();
+ NS_ENSURE_STATE(aEvent->mTarget);
}
if (retargeted) {
aEvent->originalTarget =
aEvent->originalTarget->GetTargetForEventTargetChain();
NS_ENSURE_STATE(aEvent->originalTarget);
}
else {
- aEvent->originalTarget = aEvent->target;
+ aEvent->originalTarget = aEvent->mTarget;
}
nsCOMPtr<nsIContent> content = do_QueryInterface(aEvent->originalTarget);
bool isInAnon = (content && (content->IsInAnonymousSubtree() ||
content->IsInShadowTree()));
aEvent->mFlags.mIsBeingDispatched = true;
@@ -632,17 +632,17 @@ EventDispatcher::Dispatch(nsISupports* a
targetEtci = EventTargetChainItemForChromeTarget(chain, content);
NS_ENSURE_STATE(targetEtci);
MOZ_ASSERT(&chain[0] == targetEtci);
targetEtci->PreHandleEvent(preVisitor);
}
if (preVisitor.mCanHandle) {
// At least the original target can handle the event.
// Setting the retarget to the |target| simplifies retargeting code.
- nsCOMPtr<EventTarget> t = do_QueryInterface(aEvent->target);
+ nsCOMPtr<EventTarget> t = do_QueryInterface(aEvent->mTarget);
targetEtci->SetNewTarget(t);
EventTargetChainItem* topEtci = targetEtci;
targetEtci = nullptr;
while (preVisitor.mParentTarget) {
EventTarget* parentTarget = preVisitor.mParentTarget;
EventTargetChainItem* parentEtci =
EventTargetChainItem::Create(chain, preVisitor.mParentTarget, topEtci);
if (!parentEtci->IsValid()) {
@@ -650,17 +650,17 @@ EventDispatcher::Dispatch(nsISupports* a
rv = NS_ERROR_FAILURE;
break;
}
// Item needs event retargetting.
if (preVisitor.mEventTargetAtParent) {
// Need to set the target of the event
// so that also the next retargeting works.
- preVisitor.mEvent->target = preVisitor.mEventTargetAtParent;
+ preVisitor.mEvent->mTarget = preVisitor.mEventTargetAtParent;
parentEtci->SetNewTarget(preVisitor.mEventTargetAtParent);
}
parentEtci->PreHandleEvent(preVisitor);
if (preVisitor.mCanHandle) {
topEtci = parentEtci;
} else {
EventTargetChainItem::DestroyLast(chain, parentEtci);
@@ -745,17 +745,17 @@ EventDispatcher::DispatchDOMEvent(nsISup
nsEventStatus* aEventStatus)
{
if (aDOMEvent) {
WidgetEvent* innerEvent = aDOMEvent->WidgetEventPtr();
NS_ENSURE_TRUE(innerEvent, NS_ERROR_ILLEGAL_VALUE);
bool dontResetTrusted = false;
if (innerEvent->mFlags.mDispatchedAtLeastOnce) {
- innerEvent->target = nullptr;
+ innerEvent->mTarget = nullptr;
innerEvent->originalTarget = nullptr;
} else {
aDOMEvent->GetIsTrusted(&dontResetTrusted);
}
if (!dontResetTrusted) {
//Check security state to determine if dispatcher is trusted
bool trusted = NS_IsMainThread() ? nsContentUtils::LegacyIsCallerChromeOrNativeCode()
--- a/dom/events/EventDispatcher.h
+++ b/dom/events/EventDispatcher.h
@@ -235,18 +235,18 @@ class EventDispatcher
{
public:
/**
* aTarget should QI to EventTarget.
* If the target of aEvent is set before calling this method, the target of
* aEvent is used as the target (unless there is event
* retargeting) and the originalTarget of the DOM Event.
* aTarget is always used as the starting point for constructing the event
- * target chain, no matter what the value of aEvent->target is.
- * In other words, aEvent->target is only a property of the event and it has
+ * target chain, no matter what the value of aEvent->mTarget is.
+ * In other words, aEvent->mTarget is only a property of the event and it has
* nothing to do with the construction of the event target chain.
* Neither aTarget nor aEvent is allowed to be nullptr.
*
* If aTargets is non-null, event target chain will be created, but
* event won't be handled. In this case aEvent->mMessage should be
* eVoidEvent.
* @note Use this method when dispatching a WidgetEvent.
*/
--- a/dom/events/EventStateManager.cpp
+++ b/dom/events/EventStateManager.cpp
@@ -2937,29 +2937,29 @@ EventStateManager::PostHandleEvent(nsPre
// 2. Element with NS_EVENT_STATE_DISABLED
// (aka :disabled pseudo-class for HTML element);
// 3. XUL control element has the disabled property set to 'true'.
//
// We can't use nsIFrame::IsFocusable() because we want to blur when
// we click on a visibility: none element.
// We can't use nsIContent::IsFocusable() because we want to blur when
// we click on a non-focusable element like a <div>.
- // We have to use |aEvent->target| to not make sure we do not check an
- // anonymous node of the targeted element.
+ // We have to use |aEvent->mTarget| to not make sure we do not check
+ // an anonymous node of the targeted element.
suppressBlur = (ui->mUserFocus == NS_STYLE_USER_FOCUS_IGNORE);
if (!suppressBlur) {
- nsCOMPtr<Element> element = do_QueryInterface(aEvent->target);
+ nsCOMPtr<Element> element = do_QueryInterface(aEvent->mTarget);
suppressBlur = element &&
element->State().HasState(NS_EVENT_STATE_DISABLED);
}
if (!suppressBlur) {
nsCOMPtr<nsIDOMXULControlElement> xulControl =
- do_QueryInterface(aEvent->target);
+ do_QueryInterface(aEvent->mTarget);
if (xulControl) {
bool disabled;
xulControl->GetDisabled(&disabled);
suppressBlur = disabled;
}
}
}
--- a/dom/html/HTMLLabelElement.cpp
+++ b/dom/html/HTMLLabelElement.cpp
@@ -107,17 +107,17 @@ HTMLLabelElement::PostHandleEvent(EventC
aVisitor.mEvent->mMessage != eMouseDown) ||
aVisitor.mEventStatus == nsEventStatus_eConsumeNoDefault ||
!aVisitor.mPresContext ||
// Don't handle the event if it's already been handled by another label
aVisitor.mEvent->mFlags.mMultipleActionsPrevented) {
return NS_OK;
}
- nsCOMPtr<nsIContent> target = do_QueryInterface(aVisitor.mEvent->target);
+ nsCOMPtr<nsIContent> target = do_QueryInterface(aVisitor.mEvent->mTarget);
if (InInteractiveHTMLContent(target, this)) {
return NS_OK;
}
// Strong ref because event dispatch is going to happen.
RefPtr<Element> content = GetLabeledElement();
if (content) {
--- a/layout/base/nsDocumentViewer.cpp
+++ b/layout/base/nsDocumentViewer.cpp
@@ -942,17 +942,17 @@ nsDocumentViewer::LoadComplete(nsresult
// will depend on whether it's cached!
if(window &&
(NS_SUCCEEDED(aStatus) || aStatus == NS_ERROR_PARSED_DATA_CACHED)) {
nsEventStatus status = nsEventStatus_eIgnore;
WidgetEvent event(true, eLoad);
event.mFlags.mBubbles = false;
event.mFlags.mCancelable = false;
// XXX Dispatching to |window|, but using |document| as the target.
- event.target = mDocument;
+ event.mTarget = mDocument;
// If the document presentation is being restored, we don't want to fire
// onload to the document content since that would likely confuse scripts
// on the page.
nsIDocShell *docShell = window->GetDocShell();
NS_ENSURE_TRUE(docShell, NS_ERROR_UNEXPECTED);
@@ -1300,17 +1300,17 @@ nsDocumentViewer::PageHide(bool aIsUnloa
return NS_ERROR_NULL_POINTER;
}
// Now, fire an Unload event to the document...
nsEventStatus status = nsEventStatus_eIgnore;
WidgetEvent event(true, eUnload);
event.mFlags.mBubbles = false;
// XXX Dispatching to |window|, but using |document| as the target.
- event.target = mDocument;
+ event.mTarget = mDocument;
// Never permit popups from the unload handler, no matter how we get
// here.
nsAutoPopupStatePusher popupStatePusher(openAbused, true);
EventDispatcher::Dispatch(window, mPresContext, &event, nullptr, &status);
}
--- a/layout/base/nsPresShell.cpp
+++ b/layout/base/nsPresShell.cpp
@@ -8176,17 +8176,17 @@ PresShell::HandleEventInternal(WidgetEve
EventStateManager::GetActiveEventStateManager() == manager);
}
nsAutoPopupStatePusher popupStatePusher(
Event::GetEventPopupControlState(aEvent));
// FIXME. If the event was reused, we need to clear the old target,
// bug 329430
- aEvent->target = nullptr;
+ aEvent->mTarget = nullptr;
// 1. Give event to event manager for pre event state changes and
// generation of synthetic events.
rv = manager->PreHandleEvent(mPresContext, aEvent, mCurrentEventFrame,
mCurrentEventContent, aStatus);
// 2. Give event to the DOM for third party and JS use.
if (NS_SUCCEEDED(rv)) {
@@ -8368,17 +8368,17 @@ PresShell::DispatchTouchEventToDOM(Widge
continue;
}
content = capturingContent;
}
// copy the event
WidgetTouchEvent newEvent(touchEvent->IsTrusted(),
touchEvent->mMessage, touchEvent->mWidget);
newEvent.AssignTouchEventData(*touchEvent, false);
- newEvent.target = targetPtr;
+ newEvent.mTarget = targetPtr;
RefPtr<PresShell> contentPresShell;
if (doc == mDocument) {
contentPresShell = static_cast<PresShell*>(doc->GetShell());
if (contentPresShell) {
//XXXsmaug huge hack. Pushing possibly capturing content,
// even though event target is something else.
contentPresShell->PushCurrentEventInfo(
--- a/widget/BasicEvents.h
+++ b/widget/BasicEvents.h
@@ -341,31 +341,31 @@ public:
nsCOMPtr<nsIAtom> mSpecifiedEventType;
// nsIAtom isn't available on non-main thread due to unsafe. Therefore,
// mSpecifiedEventTypeString is used instead of mSpecifiedEventType if
// the event is created in non-main thread.
nsString mSpecifiedEventTypeString;
// Event targets, needed by DOM Events
- nsCOMPtr<dom::EventTarget> target;
+ nsCOMPtr<dom::EventTarget> mTarget;
nsCOMPtr<dom::EventTarget> currentTarget;
nsCOMPtr<dom::EventTarget> originalTarget;
void AssignEventData(const WidgetEvent& aEvent, bool aCopyTargets)
{
// mClass should be initialized with the constructor.
// mMessage should be initialized with the constructor.
mRefPoint = aEvent.mRefPoint;
// mLastRefPoint doesn't need to be copied.
AssignEventTime(aEvent);
// mFlags should be copied manually if it's necessary.
mSpecifiedEventType = aEvent.mSpecifiedEventType;
// mSpecifiedEventTypeString should be copied manually if it's necessary.
- target = aCopyTargets ? aEvent.target : nullptr;
+ mTarget = aCopyTargets ? aEvent.mTarget : nullptr;
currentTarget = aCopyTargets ? aEvent.currentTarget : nullptr;
originalTarget = aCopyTargets ? aEvent.originalTarget : nullptr;
}
/**
* Helper methods for methods of DOM Event.
*/
void StopPropagation() { mFlags.StopPropagation(); }