corysanin/tubestation
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bug 874842 - Return Event instead of nsIDOMEvent

Browse Source
This commit is contained in:
Aryeh Gregor
2015-08-12 14:39:31 +03:00
parent 38e1f3ca4b
commit 6e1dae88e0
96 changed files with 518 additions and 712 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
dom/base/DOMRequest.cpp
View File

@@ -9,8 +9,8 @@
#include "DOMError.h" #include "DOMError.h"
#include "nsThreadUtils.h" #include "nsThreadUtils.h"
#include "DOMCursor.h" #include "DOMCursor.h"
#include "nsIDOMEvent.h"
#include "mozilla/ErrorResult.h" #include "mozilla/ErrorResult.h"
#include "mozilla/dom/Event.h"
#include "mozilla/dom/Promise.h" #include "mozilla/dom/Promise.h"
#include "mozilla/dom/ScriptSettings.h" #include "mozilla/dom/ScriptSettings.h"
@@ -192,8 +192,7 @@ DOMRequest::FireEvent(const nsAString& aType, bool aBubble, bool aCancelable)
return; return;
} }
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
NS_NewDOMEvent(getter_AddRefs(event), this, nullptr, nullptr);
nsresult rv = event->InitEvent(aType, aBubble, aCancelable); nsresult rv = event->InitEvent(aType, aBubble, aCancelable);
if (NS_FAILED(rv)) { if (NS_FAILED(rv)) {
return; return;

42
dom/base/EventSource.cpp
View File

@@ -845,12 +845,7 @@ EventSource::AnnounceConnection()
return; return;
} }
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
rv = NS_NewDOMEvent(getter_AddRefs(event), this, nullptr, nullptr);
if (NS_FAILED(rv)) {
NS_WARNING("Failed to create the open event!!!");
return;
}
// it doesn't bubble, and it isn't cancelable // it doesn't bubble, and it isn't cancelable
rv = event->InitEvent(NS_LITERAL_STRING("open"), false, false); rv = event->InitEvent(NS_LITERAL_STRING("open"), false, false);
@@ -910,12 +905,7 @@ EventSource::ReestablishConnection()
return; return;
} }
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
rv = NS_NewDOMEvent(getter_AddRefs(event), this, nullptr, nullptr);
if (NS_FAILED(rv)) {
NS_WARNING("Failed to create the error event!!!");
return;
}
// it doesn't bubble, and it isn't cancelable // it doesn't bubble, and it isn't cancelable
rv = event->InitEvent(NS_LITERAL_STRING("error"), false, false); rv = event->InitEvent(NS_LITERAL_STRING("error"), false, false);
@@ -1066,12 +1056,7 @@ EventSource::FailConnection()
return; return;
} }
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
rv = NS_NewDOMEvent(getter_AddRefs(event), this, nullptr, nullptr);
if (NS_FAILED(rv)) {
NS_WARNING("Failed to create the error event!!!");
return;
}
// it doesn't bubble, and it isn't cancelable // it doesn't bubble, and it isn't cancelable
rv = event->InitEvent(NS_LITERAL_STRING("error"), false, false); rv = event->InitEvent(NS_LITERAL_STRING("error"), false, false);
@@ -1234,27 +1219,20 @@ EventSource::DispatchAllMessageEvents()
// create an event that uses the MessageEvent interface, // create an event that uses the MessageEvent interface,
// which does not bubble, is not cancelable, and has no default action // which does not bubble, is not cancelable, and has no default action
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<MessageEvent> event =
rv = NS_NewDOMMessageEvent(getter_AddRefs(event), this, nullptr, nullptr); NS_NewDOMMessageEvent(this, nullptr, nullptr);
if (NS_FAILED(rv)) {
NS_WARNING("Failed to create the message event!!!");
return;
}
nsCOMPtr<nsIDOMMessageEvent> messageEvent = do_QueryInterface(event); rv = event->InitMessageEvent(message->mEventName, false, false, jsData,
rv = messageEvent->InitMessageEvent(message->mEventName, mOrigin, message->mLastEventID, nullptr);
false, false,
jsData,
mOrigin,
message->mLastEventID, nullptr);
if (NS_FAILED(rv)) { if (NS_FAILED(rv)) {
NS_WARNING("Failed to init the message event!!!"); NS_WARNING("Failed to init the message event!!!");
return; return;
} }
messageEvent->SetTrusted(true); event->SetTrusted(true);
rv = DispatchDOMEvent(nullptr, event, nullptr, nullptr); rv = DispatchDOMEvent(nullptr, static_cast<Event*>(event), nullptr,
nullptr);
if (NS_FAILED(rv)) { if (NS_FAILED(rv)) {
NS_WARNING("Failed to dispatch the message event!!!"); NS_WARNING("Failed to dispatch the message event!!!");
return; return;

22
dom/base/WebSocket.cpp
View File

@@ -13,6 +13,7 @@
#include "mozilla/DOMEventTargetHelper.h" #include "mozilla/DOMEventTargetHelper.h"
#include "mozilla/net/WebSocketChannel.h" #include "mozilla/net/WebSocketChannel.h"
#include "mozilla/dom/File.h" #include "mozilla/dom/File.h"
#include "mozilla/dom/MessageEvent.h"
#include "mozilla/dom/nsCSPContext.h" #include "mozilla/dom/nsCSPContext.h"
#include "mozilla/dom/nsCSPUtils.h" #include "mozilla/dom/nsCSPUtils.h"
#include "mozilla/dom/ScriptSettings.h" #include "mozilla/dom/ScriptSettings.h"
@@ -30,7 +31,6 @@
#include "nsIURL.h" #include "nsIURL.h"
#include "nsIUnicodeEncoder.h" #include "nsIUnicodeEncoder.h"
#include "nsThreadUtils.h" #include "nsThreadUtils.h"
#include "nsIDOMMessageEvent.h"
#include "nsIPromptFactory.h" #include "nsIPromptFactory.h"
#include "nsIWindowWatcher.h" #include "nsIWindowWatcher.h"
#include "nsIPrompt.h" #include "nsIPrompt.h"
@@ -1737,9 +1737,7 @@ WebSocket::CreateAndDispatchSimpleEvent(const nsAString& aName)
return NS_OK; return NS_OK;
} }
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
rv = NS_NewDOMEvent(getter_AddRefs(event), this, nullptr, nullptr);
NS_ENSURE_SUCCESS(rv, rv);
// it doesn't bubble, and it isn't cancelable // it doesn't bubble, and it isn't cancelable
rv = event->InitEvent(aName, false, false); rv = event->InitEvent(aName, false, false);
@@ -1817,21 +1815,17 @@ WebSocket::CreateAndDispatchMessageEvent(JSContext* aCx,
// create an event that uses the MessageEvent interface, // create an event that uses the MessageEvent interface,
// which does not bubble, is not cancelable, and has no default action // which does not bubble, is not cancelable, and has no default action
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<MessageEvent> event = NS_NewDOMMessageEvent(this, nullptr, nullptr);
rv = NS_NewDOMMessageEvent(getter_AddRefs(event), this, nullptr, nullptr);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIDOMMessageEvent> messageEvent = do_QueryInterface(event); rv = event->InitMessageEvent(NS_LITERAL_STRING("message"), false, false,
rv = messageEvent->InitMessageEvent(NS_LITERAL_STRING("message"), jsData, mImpl->mUTF16Origin, EmptyString(),
false, false, nullptr);
jsData,
mImpl->mUTF16Origin,
EmptyString(), nullptr);
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
event->SetTrusted(true); event->SetTrusted(true);
return DispatchDOMEvent(nullptr, event, nullptr, nullptr); return DispatchDOMEvent(nullptr, static_cast<Event*>(event), nullptr,
nullptr);
} }
nsresult nsresult

19
dom/base/nsDOMDataChannel.cpp
View File

@@ -17,9 +17,9 @@ extern PRLogModuleInfo* GetDataChannelLog();
#include "nsDOMDataChannelDeclarations.h" #include "nsDOMDataChannelDeclarations.h"
#include "nsDOMDataChannel.h" #include "nsDOMDataChannel.h"
#include "nsIDOMDataChannel.h" #include "nsIDOMDataChannel.h"
#include "nsIDOMMessageEvent.h"
#include "mozilla/DOMEventTargetHelper.h" #include "mozilla/DOMEventTargetHelper.h"
#include "mozilla/dom/File.h" #include "mozilla/dom/File.h"
#include "mozilla/dom/MessageEvent.h"
#include "mozilla/dom/ScriptSettings.h" #include "mozilla/dom/ScriptSettings.h"
#include "nsError.h" #include "nsError.h"
@@ -401,20 +401,15 @@ nsDOMDataChannel::DoOnMessageAvailable(const nsACString& aData,
jsData.setString(jsString); jsData.setString(jsString);
} }
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<MessageEvent> event = NS_NewDOMMessageEvent(this, nullptr, nullptr);
rv = NS_NewDOMMessageEvent(getter_AddRefs(event), this, nullptr, nullptr);
NS_ENSURE_SUCCESS(rv,rv);
nsCOMPtr<nsIDOMMessageEvent> messageEvent = do_QueryInterface(event); rv = event->InitMessageEvent(NS_LITERAL_STRING("message"), false, false,
rv = messageEvent->InitMessageEvent(NS_LITERAL_STRING("message"), jsData, mOrigin, EmptyString(), nullptr);
false, false,
jsData, mOrigin, EmptyString(),
nullptr);
NS_ENSURE_SUCCESS(rv,rv); NS_ENSURE_SUCCESS(rv,rv);
event->SetTrusted(true); event->SetTrusted(true);
LOG(("%p(%p): %s - Dispatching\n",this,(void*)mDataChannel,__FUNCTION__)); LOG(("%p(%p): %s - Dispatching\n",this,(void*)mDataChannel,__FUNCTION__));
rv = DispatchDOMEvent(nullptr, event, nullptr, nullptr); rv = DispatchDOMEvent(nullptr, static_cast<Event*>(event), nullptr, nullptr);
if (NS_FAILED(rv)) { if (NS_FAILED(rv)) {
NS_WARNING("Failed to dispatch the message event!!!"); NS_WARNING("Failed to dispatch the message event!!!");
} }
@@ -447,9 +442,7 @@ nsDOMDataChannel::OnSimpleEvent(nsISupports* aContext, const nsAString& aName)
return NS_OK; return NS_OK;
} }
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
rv = NS_NewDOMEvent(getter_AddRefs(event), this, nullptr, nullptr);
NS_ENSURE_SUCCESS(rv,rv);
rv = event->InitEvent(aName, false, false); rv = event->InitEvent(aName, false, false);
NS_ENSURE_SUCCESS(rv,rv); NS_ENSURE_SUCCESS(rv,rv);

13
dom/base/nsDocument.cpp
View File

@@ -8132,17 +8132,17 @@ nsIDocument::CreateEvent(const nsAString& aEventType, ErrorResult& rv) const
} }
// Create event even without presContext. // Create event even without presContext.
nsCOMPtr<nsIDOMEvent> ev; nsRefPtr<Event> ev =
rv = EventDispatcher::CreateEvent(const_cast<nsIDocument*>(this), EventDispatcher::CreateEvent(const_cast<nsIDocument*>(this), presContext,
presContext, nullptr, aEventType, nullptr, aEventType);
getter_AddRefs(ev));
if (!ev) { if (!ev) {
rv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
return nullptr; return nullptr;
} }
WidgetEvent* e = ev->GetInternalNSEvent(); WidgetEvent* e = ev->GetInternalNSEvent();
e->mFlags.mBubbles = false; e->mFlags.mBubbles = false;
e->mFlags.mCancelable = false; e->mFlags.mCancelable = false;
return dont_AddRef(ev.forget().take()->InternalDOMEvent()); return ev.forget();
} }
void void
@@ -9209,8 +9209,7 @@ static void
DispatchCustomEventWithFlush(nsINode* aTarget, const nsAString& aEventType, DispatchCustomEventWithFlush(nsINode* aTarget, const nsAString& aEventType,
bool aBubbles, bool aOnlyChromeDispatch) bool aBubbles, bool aOnlyChromeDispatch)
{ {
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<Event> event = NS_NewDOMEvent(aTarget, nullptr, nullptr);
NS_NewDOMEvent(getter_AddRefs(event), aTarget, nullptr, nullptr);
nsresult rv = event->InitEvent(aEventType, aBubbles, false); nsresult rv = event->InitEvent(aEventType, aBubbles, false);
if (NS_FAILED(rv)) { if (NS_FAILED(rv)) {
return; return;

9
dom/base/nsGlobalWindow.cpp
View File

@@ -9101,8 +9101,7 @@ nsGlobalWindow::LeaveModalState()
inner->mLastDialogQuitTime = TimeStamp::Now(); inner->mLastDialogQuitTime = TimeStamp::Now();
if (topWin->mModalStateDepth == 0) { if (topWin->mModalStateDepth == 0) {
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<Event> event = NS_NewDOMEvent(topWin, nullptr, nullptr);
NS_NewDOMEvent(getter_AddRefs(event), topWin, nullptr, nullptr);
event->InitEvent(NS_LITERAL_STRING("endmodalstate"), true, false); event->InitEvent(NS_LITERAL_STRING("endmodalstate"), true, false);
event->SetTrusted(true); event->SetTrusted(true);
event->GetInternalNSEvent()->mFlags.mOnlyChromeDispatch = true; event->GetInternalNSEvent()->mFlags.mOnlyChromeDispatch = true;
@@ -11890,8 +11889,7 @@ nsGlobalWindow::Observe(nsISupports* aSubject, const char* aTopic,
return NS_OK; return NS_OK;
} }
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
NS_NewDOMEvent(getter_AddRefs(event), this, nullptr, nullptr);
nsresult rv = event->InitEvent( nsresult rv = event->InitEvent(
!nsCRT::strcmp(aTopic, NS_NETWORK_ACTIVITY_BLIP_UPLOAD_TOPIC) !nsCRT::strcmp(aTopic, NS_NETWORK_ACTIVITY_BLIP_UPLOAD_TOPIC)
? NETWORK_UPLOAD_EVENT_NAME ? NETWORK_UPLOAD_EVENT_NAME
@@ -11927,8 +11925,7 @@ nsGlobalWindow::Observe(nsISupports* aSubject, const char* aTopic,
return NS_OK; return NS_OK;
} }
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
NS_NewDOMEvent(getter_AddRefs(event), this, nullptr, nullptr);
nsresult rv = event->InitEvent(NS_LITERAL_STRING("languagechange"), false, false); nsresult rv = event->InitEvent(NS_LITERAL_STRING("languagechange"), false, false);
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);

17
dom/base/nsPerformance.cpp
View File

@@ -478,16 +478,15 @@ nsPerformance::Timing()
void void
nsPerformance::DispatchBufferFullEvent() nsPerformance::DispatchBufferFullEvent()
{ {
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
nsresult rv = NS_NewDOMEvent(getter_AddRefs(event), this, nullptr, nullptr); // it bubbles, and it isn't cancelable
if (NS_SUCCEEDED(rv)) { nsresult rv = event->InitEvent(NS_LITERAL_STRING("resourcetimingbufferfull"),
// it bubbles, and it isn't cancelable true, false);
rv = event->InitEvent(NS_LITERAL_STRING("resourcetimingbufferfull"), true, false); if (NS_FAILED(rv)) {
if (NS_SUCCEEDED(rv)) { return;
event->SetTrusted(true);
DispatchDOMEvent(nullptr, event, nullptr, nullptr);
}
} }
event->SetTrusted(true);
DispatchDOMEvent(nullptr, event, nullptr, nullptr);
} }
nsPerformanceNavigation* nsPerformanceNavigation*

8
dom/base/nsXMLHttpRequest.cpp
View File

@@ -1467,12 +1467,8 @@ nsXMLHttpRequest::GetLoadGroup() const
nsresult nsresult
nsXMLHttpRequest::CreateReadystatechangeEvent(nsIDOMEvent** aDOMEvent) nsXMLHttpRequest::CreateReadystatechangeEvent(nsIDOMEvent** aDOMEvent)
{ {
nsresult rv = EventDispatcher::CreateEvent(this, nullptr, nullptr, nsRefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
NS_LITERAL_STRING("Events"), event.forget(aDOMEvent);
aDOMEvent);
if (NS_FAILED(rv)) {
return rv;
}
(*aDOMEvent)->InitEvent(NS_LITERAL_STRING(READYSTATE_STR), (*aDOMEvent)->InitEvent(NS_LITERAL_STRING(READYSTATE_STR),
false, false); false, false);

7
dom/bluetooth/bluetooth1/BluetoothAdapter.cpp
View File

@@ -16,6 +16,7 @@
#include "mozilla/dom/BluetoothDiscoveryStateChangedEvent.h" #include "mozilla/dom/BluetoothDiscoveryStateChangedEvent.h"
#include "mozilla/dom/BluetoothStatusChangedEvent.h" #include "mozilla/dom/BluetoothStatusChangedEvent.h"
#include "mozilla/dom/ContentChild.h" #include "mozilla/dom/ContentChild.h"
#include "mozilla/dom/Event.h"
#include "mozilla/dom/File.h" #include "mozilla/dom/File.h"
#include "mozilla/dom/ScriptSettings.h" #include "mozilla/dom/ScriptSettings.h"
#include "mozilla/LazyIdleThread.h" #include "mozilla/LazyIdleThread.h"
@@ -361,11 +362,9 @@ BluetoothAdapter::Notify(const BluetoothSignal& aData)
BluetoothStatusChangedEvent::Constructor(this, aData.name(), init); BluetoothStatusChangedEvent::Constructor(this, aData.name(), init);
DispatchTrustedEvent(event); DispatchTrustedEvent(event);
} else if (aData.name().EqualsLiteral(REQUEST_MEDIA_PLAYSTATUS_ID)) { } else if (aData.name().EqualsLiteral(REQUEST_MEDIA_PLAYSTATUS_ID)) {
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
nsresult rv = NS_NewDOMEvent(getter_AddRefs(event), this, nullptr, nullptr);
NS_ENSURE_SUCCESS_VOID(rv);
rv = event->InitEvent(aData.name(), false, false); nsresult rv = event->InitEvent(aData.name(), false, false);
NS_ENSURE_SUCCESS_VOID(rv); NS_ENSURE_SUCCESS_VOID(rv);
DispatchTrustedEvent(event); DispatchTrustedEvent(event);

7
dom/bluetooth/bluetooth2/BluetoothAdapter.cpp
View File

@@ -16,6 +16,7 @@
#include "mozilla/dom/BluetoothAttributeEvent.h" #include "mozilla/dom/BluetoothAttributeEvent.h"
#include "mozilla/dom/BluetoothStatusChangedEvent.h" #include "mozilla/dom/BluetoothStatusChangedEvent.h"
#include "mozilla/dom/ContentChild.h" #include "mozilla/dom/ContentChild.h"
#include "mozilla/dom/Event.h"
#include "mozilla/dom/File.h" #include "mozilla/dom/File.h"
#include "mozilla/dom/bluetooth/BluetoothAdapter.h" #include "mozilla/dom/bluetooth/BluetoothAdapter.h"
@@ -1196,11 +1197,9 @@ BluetoothAdapter::DispatchDeviceEvent(const nsAString& aType,
void void
BluetoothAdapter::DispatchEmptyEvent(const nsAString& aType) BluetoothAdapter::DispatchEmptyEvent(const nsAString& aType)
{ {
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
nsresult rv = NS_NewDOMEvent(getter_AddRefs(event), this, nullptr, nullptr);
NS_ENSURE_SUCCESS_VOID(rv);
rv = event->InitEvent(aType, false, false); nsresult rv = event->InitEvent(aType, false, false);
NS_ENSURE_SUCCESS_VOID(rv); NS_ENSURE_SUCCESS_VOID(rv);
DispatchTrustedEvent(event); DispatchTrustedEvent(event);

12
dom/bluetooth/bluetooth2/BluetoothGatt.cpp
View File

@@ -12,6 +12,7 @@
#include "mozilla/dom/bluetooth/BluetoothTypes.h" #include "mozilla/dom/bluetooth/BluetoothTypes.h"
#include "mozilla/dom/BluetoothGattBinding.h" #include "mozilla/dom/BluetoothGattBinding.h"
#include "mozilla/dom/BluetoothGattCharacteristicEvent.h" #include "mozilla/dom/BluetoothGattCharacteristicEvent.h"
#include "mozilla/dom/Event.h"
#include "mozilla/dom/Promise.h" #include "mozilla/dom/Promise.h"
#include "nsServiceManagerUtils.h" #include "nsServiceManagerUtils.h"
@@ -240,13 +241,12 @@ BluetoothGatt::UpdateConnectionState(BluetoothConnectionState aState)
mConnectionState = aState; mConnectionState = aState;
// Dispatch connectionstatechanged event to application // Dispatch connectionstatechanged event to application
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
nsresult rv = NS_NewDOMEvent(getter_AddRefs(event), this, nullptr, nullptr);
NS_ENSURE_SUCCESS_VOID(rv);
rv = event->InitEvent(NS_LITERAL_STRING(GATT_CONNECTION_STATE_CHANGED_ID), nsresult rv =
false, event->InitEvent(NS_LITERAL_STRING(GATT_CONNECTION_STATE_CHANGED_ID),
false); false,
false);
NS_ENSURE_SUCCESS_VOID(rv); NS_ENSURE_SUCCESS_VOID(rv);
DispatchTrustedEvent(event); DispatchTrustedEvent(event);

15
dom/browser-element/BrowserElementParent.cpp
View File

@@ -102,16 +102,10 @@ DispatchCustomDOMEvent(Element* aFrameElement, const nsAString& aEventName,
presContext = shell->GetPresContext(); presContext = shell->GetPresContext();
} }
nsCOMPtr<nsIDOMEvent> domEvent; nsRefPtr<CustomEvent> event =
EventDispatcher::CreateEvent(aFrameElement, presContext, nullptr, NS_NewDOMCustomEvent(aFrameElement, presContext, nullptr);
NS_LITERAL_STRING("customevent"),
getter_AddRefs(domEvent));
NS_ENSURE_TRUE(domEvent, false);
nsCOMPtr<nsIDOMCustomEvent> customEvent = do_QueryInterface(domEvent);
NS_ENSURE_TRUE(customEvent, false);
ErrorResult res; ErrorResult res;
CustomEvent* event = static_cast<CustomEvent*>(customEvent.get());
event->InitCustomEvent(cx, event->InitCustomEvent(cx,
aEventName, aEventName,
/* bubbles = */ true, /* bubbles = */ true,
@@ -121,12 +115,13 @@ DispatchCustomDOMEvent(Element* aFrameElement, const nsAString& aEventName,
if (res.Failed()) { if (res.Failed()) {
return false; return false;
} }
customEvent->SetTrusted(true); event->SetTrusted(true);
// Dispatch the event. // Dispatch the event.
*aStatus = nsEventStatus_eConsumeNoDefault; *aStatus = nsEventStatus_eConsumeNoDefault;
nsresult rv = nsresult rv =
EventDispatcher::DispatchDOMEvent(aFrameElement, nullptr, EventDispatcher::DispatchDOMEvent(aFrameElement, nullptr,
domEvent, presContext, aStatus); static_cast<Event*>(event),
presContext, aStatus);
return NS_SUCCEEDED(rv); return NS_SUCCEEDED(rv);
} }

12
dom/events/AnimationEvent.cpp
View File

@@ -88,14 +88,12 @@ AnimationEvent::GetPseudoElement(nsAString& aPseudoElement)
using namespace mozilla; using namespace mozilla;
using namespace mozilla::dom; using namespace mozilla::dom;
nsresult already_AddRefed<AnimationEvent>
NS_NewDOMAnimationEvent(nsIDOMEvent** aInstancePtrResult, NS_NewDOMAnimationEvent(EventTarget* aOwner,
EventTarget* aOwner,
nsPresContext* aPresContext, nsPresContext* aPresContext,
InternalAnimationEvent* aEvent) InternalAnimationEvent* aEvent)
{ {
AnimationEvent* it = new AnimationEvent(aOwner, aPresContext, aEvent); nsRefPtr<AnimationEvent> it =
NS_ADDREF(it); new AnimationEvent(aOwner, aPresContext, aEvent);
*aInstancePtrResult = static_cast<Event*>(it); return it.forget();
return NS_OK;
} }

5
dom/events/AnimationEvent.h
View File

@@ -52,4 +52,9 @@ protected:
} // namespace dom } // namespace dom
} // namespace mozilla } // namespace mozilla
already_AddRefed<mozilla::dom::AnimationEvent>
NS_NewDOMAnimationEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::InternalAnimationEvent* aEvent);
#endif // mozilla_dom_AnimationEvent_h_ #endif // mozilla_dom_AnimationEvent_h_

11
dom/events/AsyncEventDispatcher.cpp
View File

@@ -26,8 +26,9 @@ AsyncEventDispatcher::AsyncEventDispatcher(EventTarget* aTarget,
, mOnlyChromeDispatch(false) , mOnlyChromeDispatch(false)
{ {
MOZ_ASSERT(mTarget); MOZ_ASSERT(mTarget);
EventDispatcher::CreateEvent(aTarget, nullptr, &aEvent, EmptyString(), nsRefPtr<Event> event =
getter_AddRefs(mEvent)); EventDispatcher::CreateEvent(aTarget, nullptr, &aEvent, EmptyString());
mEvent = do_QueryInterface(event);
NS_ASSERTION(mEvent, "Should never fail to create an event"); NS_ASSERTION(mEvent, "Should never fail to create an event");
mEvent->DuplicatePrivateData(); mEvent->DuplicatePrivateData();
mEvent->SetTrusted(aEvent.mFlags.mIsTrusted); mEvent->SetTrusted(aEvent.mFlags.mIsTrusted);
@@ -36,15 +37,15 @@ AsyncEventDispatcher::AsyncEventDispatcher(EventTarget* aTarget,
NS_IMETHODIMP NS_IMETHODIMP
AsyncEventDispatcher::Run() AsyncEventDispatcher::Run()
{ {
nsCOMPtr<nsIDOMEvent> event = mEvent; nsRefPtr<Event> event = mEvent ? mEvent->InternalDOMEvent() : nullptr;
if (!event) { if (!event) {
NS_NewDOMEvent(getter_AddRefs(event), mTarget, nullptr, nullptr); event = NS_NewDOMEvent(mTarget, nullptr, nullptr);
nsresult rv = event->InitEvent(mEventType, mBubbles, false); nsresult rv = event->InitEvent(mEventType, mBubbles, false);
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
event->SetTrusted(true); event->SetTrusted(true);
} }
if (mOnlyChromeDispatch) { if (mOnlyChromeDispatch) {
MOZ_ASSERT(event->InternalDOMEvent()->IsTrusted()); MOZ_ASSERT(event->IsTrusted());
event->GetInternalNSEvent()->mFlags.mOnlyChromeDispatch = true; event->GetInternalNSEvent()->mFlags.mOnlyChromeDispatch = true;
} }
bool dummy; bool dummy;

12
dom/events/BeforeAfterKeyboardEvent.cpp
View File

@@ -78,16 +78,12 @@ BeforeAfterKeyboardEvent::GetEmbeddedCancelled()
using namespace mozilla; using namespace mozilla;
using namespace mozilla::dom; using namespace mozilla::dom;
nsresult already_AddRefed<BeforeAfterKeyboardEvent>
NS_NewDOMBeforeAfterKeyboardEvent(nsIDOMEvent** aInstancePtrResult, NS_NewDOMBeforeAfterKeyboardEvent(EventTarget* aOwner,
EventTarget* aOwner,
nsPresContext* aPresContext, nsPresContext* aPresContext,
InternalBeforeAfterKeyboardEvent* aEvent) InternalBeforeAfterKeyboardEvent* aEvent)
{ {
BeforeAfterKeyboardEvent* it = nsRefPtr<BeforeAfterKeyboardEvent> it =
new BeforeAfterKeyboardEvent(aOwner, aPresContext, aEvent); new BeforeAfterKeyboardEvent(aOwner, aPresContext, aEvent);
return it.forget();
NS_ADDREF(it);
*aInstancePtrResult = static_cast<Event*>(it);
return NS_OK;
} }

5
dom/events/BeforeAfterKeyboardEvent.h
View File

@@ -43,4 +43,9 @@ public:
} // namespace dom } // namespace dom
} // namespace mozilla } // namespace mozilla
already_AddRefed<mozilla::dom::BeforeAfterKeyboardEvent>
NS_NewDOMBeforeAfterKeyboardEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::InternalBeforeAfterKeyboardEvent* aEvent);
#endif // mozilla_dom_BeforeAfterKeyboardEvent_h_ #endif // mozilla_dom_BeforeAfterKeyboardEvent_h_

12
dom/events/BeforeUnloadEvent.cpp
View File

@@ -36,14 +36,12 @@ BeforeUnloadEvent::GetReturnValue(nsAString& aReturnValue)
using namespace mozilla; using namespace mozilla;
using namespace mozilla::dom; using namespace mozilla::dom;
nsresult already_AddRefed<BeforeUnloadEvent>
NS_NewDOMBeforeUnloadEvent(nsIDOMEvent** aInstancePtrResult, NS_NewDOMBeforeUnloadEvent(EventTarget* aOwner,
EventTarget* aOwner,
nsPresContext* aPresContext, nsPresContext* aPresContext,
WidgetEvent* aEvent) WidgetEvent* aEvent)
{ {
BeforeUnloadEvent* it = new BeforeUnloadEvent(aOwner, aPresContext, aEvent); nsRefPtr<BeforeUnloadEvent> it =
NS_ADDREF(it); new BeforeUnloadEvent(aOwner, aPresContext, aEvent);
*aInstancePtrResult = static_cast<Event*>(it); return it.forget();
return NS_OK;
} }

5
dom/events/BeforeUnloadEvent.h
View File

@@ -47,4 +47,9 @@ protected:
} // namespace dom } // namespace dom
} // namespace mozilla } // namespace mozilla
already_AddRefed<mozilla::dom::BeforeUnloadEvent>
NS_NewDOMBeforeUnloadEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetEvent* aEvent);
#endif // mozilla_dom_BeforeUnloadEvent_h_ #endif // mozilla_dom_BeforeUnloadEvent_h_

12
dom/events/ClipboardEvent.cpp
View File

@@ -123,14 +123,12 @@ ClipboardEvent::GetClipboardData()
using namespace mozilla; using namespace mozilla;
using namespace mozilla::dom; using namespace mozilla::dom;
nsresult already_AddRefed<ClipboardEvent>
NS_NewDOMClipboardEvent(nsIDOMEvent** aInstancePtrResult, NS_NewDOMClipboardEvent(EventTarget* aOwner,
EventTarget* aOwner,
nsPresContext* aPresContext, nsPresContext* aPresContext,
InternalClipboardEvent* aEvent) InternalClipboardEvent* aEvent)
{ {
ClipboardEvent* it = new ClipboardEvent(aOwner, aPresContext, aEvent); nsRefPtr<ClipboardEvent> it =
NS_ADDREF(it); new ClipboardEvent(aOwner, aPresContext, aEvent);
*aInstancePtrResult = static_cast<Event*>(it); return it.forget();
return NS_OK;
} }

5
dom/events/ClipboardEvent.h
View File

@@ -56,4 +56,9 @@ protected:
} // namespace dom } // namespace dom
} // namespace mozilla } // namespace mozilla
already_AddRefed<mozilla::dom::ClipboardEvent>
NS_NewDOMClipboardEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::InternalClipboardEvent* aEvent);
#endif // mozilla_dom_ClipboardEvent_h_ #endif // mozilla_dom_ClipboardEvent_h_

12
dom/events/CommandEvent.cpp
View File

@@ -64,14 +64,12 @@ CommandEvent::InitCommandEvent(const nsAString& aTypeArg,
using namespace mozilla; using namespace mozilla;
using namespace mozilla::dom; using namespace mozilla::dom;
nsresult already_AddRefed<CommandEvent>
NS_NewDOMCommandEvent(nsIDOMEvent** aInstancePtrResult, NS_NewDOMCommandEvent(EventTarget* aOwner,
EventTarget* aOwner,
nsPresContext* aPresContext, nsPresContext* aPresContext,
WidgetCommandEvent* aEvent) WidgetCommandEvent* aEvent)
{ {
CommandEvent* it = new CommandEvent(aOwner, aPresContext, aEvent); nsRefPtr<CommandEvent> it =
NS_ADDREF(it); new CommandEvent(aOwner, aPresContext, aEvent);
*aInstancePtrResult = static_cast<Event*>(it); return it.forget();
return NS_OK;
} }

5
dom/events/CommandEvent.h
View File

@@ -51,4 +51,9 @@ protected:
} // namespace dom } // namespace dom
} // namespace mozilla } // namespace mozilla
already_AddRefed<mozilla::dom::CommandEvent>
NS_NewDOMCommandEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetCommandEvent* aEvent);
#endif // mozilla_dom_CommandEvent_h_ #endif // mozilla_dom_CommandEvent_h_

10
dom/events/CompositionEvent.cpp
View File

@@ -80,12 +80,12 @@ CompositionEvent::InitCompositionEvent(const nsAString& aType,
using namespace mozilla; using namespace mozilla;
using namespace mozilla::dom; using namespace mozilla::dom;
nsresult already_AddRefed<CompositionEvent>
NS_NewDOMCompositionEvent(nsIDOMEvent** aInstancePtrResult, NS_NewDOMCompositionEvent(EventTarget* aOwner,
EventTarget* aOwner,
nsPresContext* aPresContext, nsPresContext* aPresContext,
WidgetCompositionEvent* aEvent) WidgetCompositionEvent* aEvent)
{ {
CompositionEvent* event = new CompositionEvent(aOwner, aPresContext, aEvent); nsRefPtr<CompositionEvent> event =
return CallQueryInterface(event, aInstancePtrResult); new CompositionEvent(aOwner, aPresContext, aEvent);
return event.forget();
} }

5
dom/events/CompositionEvent.h
View File

@@ -54,4 +54,9 @@ protected:
} // namespace dom } // namespace dom
} // namespace mozilla } // namespace mozilla
already_AddRefed<mozilla::dom::CompositionEvent>
NS_NewDOMCompositionEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetCompositionEvent* aEvent);
#endif // mozilla_dom_CompositionEvent_h_ #endif // mozilla_dom_CompositionEvent_h_

12
dom/events/CustomEvent.cpp
View File

@@ -111,14 +111,12 @@ CustomEvent::GetDetail(JSContext* aCx,
VariantToJsval(aCx, mDetail, aRetval); VariantToJsval(aCx, mDetail, aRetval);
} }
nsresult already_AddRefed<CustomEvent>
NS_NewDOMCustomEvent(nsIDOMEvent** aInstancePtrResult, NS_NewDOMCustomEvent(EventTarget* aOwner,
mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext, nsPresContext* aPresContext,
mozilla::WidgetEvent* aEvent) mozilla::WidgetEvent* aEvent)
{ {
CustomEvent* it = new CustomEvent(aOwner, aPresContext, aEvent); nsRefPtr<CustomEvent> it =
NS_ADDREF(it); new CustomEvent(aOwner, aPresContext, aEvent);
*aInstancePtrResult = static_cast<Event*>(it); return it.forget();
return NS_OK;
} }

5
dom/events/CustomEvent.h
View File

@@ -58,4 +58,9 @@ public:
} // namespace dom } // namespace dom
} // namespace mozilla } // namespace mozilla
already_AddRefed<mozilla::dom::CustomEvent>
NS_NewDOMCustomEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetEvent* aEvent);
#endif // CustomEvent_h__ #endif // CustomEvent_h__

3
dom/events/DOMEventTargetHelper.cpp
View File

@@ -262,8 +262,7 @@ DOMEventTargetHelper::DispatchEvent(nsIDOMEvent* aEvent, bool* aRetVal)
nsresult nsresult
DOMEventTargetHelper::DispatchTrustedEvent(const nsAString& aEventName) DOMEventTargetHelper::DispatchTrustedEvent(const nsAString& aEventName)
{ {
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
NS_NewDOMEvent(getter_AddRefs(event), this, nullptr, nullptr);
nsresult rv = event->InitEvent(aEventName, false, false); nsresult rv = event->InitEvent(aEventName, false, false);
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);

12
dom/events/DataContainerEvent.cpp
View File

@@ -87,15 +87,13 @@ DataContainerEvent::SetData(JSContext* aCx, const nsAString& aKey,
using namespace mozilla; using namespace mozilla;
using namespace mozilla::dom; using namespace mozilla::dom;
nsresult already_AddRefed<DataContainerEvent>
NS_NewDOMDataContainerEvent(nsIDOMEvent** aInstancePtrResult, NS_NewDOMDataContainerEvent(EventTarget* aOwner,
EventTarget* aOwner,
nsPresContext* aPresContext, nsPresContext* aPresContext,
WidgetEvent* aEvent) WidgetEvent* aEvent)
{ {
DataContainerEvent* it = new DataContainerEvent(aOwner, aPresContext, aEvent); nsRefPtr<DataContainerEvent> it =
NS_ADDREF(it); new DataContainerEvent(aOwner, aPresContext, aEvent);
*aInstancePtrResult = static_cast<Event*>(it); return it.forget();
return NS_OK;
} }

5
dom/events/DataContainerEvent.h
View File

@@ -57,4 +57,9 @@ private:
} // namespace dom } // namespace dom
} // namespace mozilla } // namespace mozilla
already_AddRefed<mozilla::dom::DataContainerEvent>
NS_NewDOMDataContainerEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetEvent* aEvent);
#endif // mozilla_dom_DataContainerEvent_h_ #endif // mozilla_dom_DataContainerEvent_h_

14
dom/events/DeviceMotionEvent.cpp
View File

@@ -145,16 +145,12 @@ DeviceRotationRate::~DeviceRotationRate()
using namespace mozilla; using namespace mozilla;
using namespace mozilla::dom; using namespace mozilla::dom;
nsresult already_AddRefed<DeviceMotionEvent>
NS_NewDOMDeviceMotionEvent(nsIDOMEvent** aInstancePtrResult, NS_NewDOMDeviceMotionEvent(EventTarget* aOwner,
EventTarget* aOwner,
nsPresContext* aPresContext, nsPresContext* aPresContext,
WidgetEvent* aEvent) WidgetEvent* aEvent)
{ {
NS_ENSURE_ARG_POINTER(aInstancePtrResult); nsRefPtr<DeviceMotionEvent> it =
new DeviceMotionEvent(aOwner, aPresContext, aEvent);
DeviceMotionEvent* it = new DeviceMotionEvent(aOwner, aPresContext, aEvent); return it.forget();
NS_ADDREF(it);
*aInstancePtrResult = static_cast<Event*>(it);
return NS_OK;
} }

5
dom/events/DeviceMotionEvent.h
View File

@@ -149,4 +149,9 @@ protected:
} // namespace dom } // namespace dom
} // namespace mozilla } // namespace mozilla
already_AddRefed<mozilla::dom::DeviceMotionEvent>
NS_NewDOMDeviceMotionEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetEvent* aEvent);
#endif // mozilla_dom_DeviceMotionEvent_h_ #endif // mozilla_dom_DeviceMotionEvent_h_

10
dom/events/DragEvent.cpp
View File

@@ -159,12 +159,12 @@ DragEvent::Constructor(const GlobalObject& aGlobal,
using namespace mozilla; using namespace mozilla;
using namespace mozilla::dom; using namespace mozilla::dom;
nsresult already_AddRefed<DragEvent>
NS_NewDOMDragEvent(nsIDOMEvent** aInstancePtrResult, NS_NewDOMDragEvent(EventTarget* aOwner,
EventTarget* aOwner,
nsPresContext* aPresContext, nsPresContext* aPresContext,
WidgetDragEvent* aEvent) WidgetDragEvent* aEvent)
{ {
DragEvent* event = new DragEvent(aOwner, aPresContext, aEvent); nsRefPtr<DragEvent> event =
return CallQueryInterface(event, aInstancePtrResult); new DragEvent(aOwner, aPresContext, aEvent);
return event.forget();
} }

5
dom/events/DragEvent.h
View File

@@ -61,4 +61,9 @@ protected:
} // namespace dom } // namespace dom
} // namespace mozilla } // namespace mozilla
already_AddRefed<mozilla::dom::DragEvent>
NS_NewDOMDragEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetDragEvent* aEvent);
#endif // mozilla_dom_DragEvent_h_ #endif // mozilla_dom_DragEvent_h_

11
dom/events/Event.cpp
View File

@@ -1257,14 +1257,11 @@ Event::GetShadowRelatedTarget(nsIContent* aCurrentTarget,
using namespace mozilla; using namespace mozilla;
using namespace mozilla::dom; using namespace mozilla::dom;
nsresult already_AddRefed<Event>
NS_NewDOMEvent(nsIDOMEvent** aInstancePtrResult, NS_NewDOMEvent(EventTarget* aOwner,
EventTarget* aOwner,
nsPresContext* aPresContext, nsPresContext* aPresContext,
WidgetEvent* aEvent) WidgetEvent* aEvent)
{ {
Event* it = new Event(aOwner, aPresContext, aEvent); nsRefPtr<Event> it = new Event(aOwner, aPresContext, aEvent);
NS_ADDREF(it); return it.forget();
*aInstancePtrResult = static_cast<Event*>(it);
return NS_OK;
} }

5
dom/events/Event.h
View File

@@ -340,4 +340,9 @@ ToCanonicalSupports(mozilla::dom::Event* e)
return static_cast<nsIDOMEvent*>(e); return static_cast<nsIDOMEvent*>(e);
} }
already_AddRefed<mozilla::dom::Event>
NS_NewDOMEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetEvent* aEvent);
#endif // mozilla_dom_Event_h_ #endif // mozilla_dom_Event_h_

138
dom/events/EventDispatcher.cpp
View File

@@ -15,13 +15,28 @@
#include "GeckoProfiler.h" #include "GeckoProfiler.h"
#include "mozilla/ContentEvents.h" #include "mozilla/ContentEvents.h"
#include "mozilla/dom/CloseEvent.h" #include "mozilla/dom/CloseEvent.h"
#include "mozilla/dom/CustomEvent.h"
#include "mozilla/dom/DeviceOrientationEvent.h" #include "mozilla/dom/DeviceOrientationEvent.h"
#include "mozilla/dom/EventTarget.h" #include "mozilla/dom/EventTarget.h"
#include "mozilla/dom/FocusEvent.h"
#include "mozilla/dom/HashChangeEvent.h" #include "mozilla/dom/HashChangeEvent.h"
#include "mozilla/dom/InputEvent.h"
#include "mozilla/dom/MessageEvent.h"
#include "mozilla/dom/MouseScrollEvent.h"
#include "mozilla/dom/MutationEvent.h"
#include "mozilla/dom/NotifyPaintEvent.h"
#include "mozilla/dom/PageTransitionEvent.h" #include "mozilla/dom/PageTransitionEvent.h"
#include "mozilla/dom/PointerEvent.h"
#include "mozilla/dom/PopStateEvent.h" #include "mozilla/dom/PopStateEvent.h"
#include "mozilla/dom/ScrollAreaEvent.h"
#include "mozilla/dom/SimpleGestureEvent.h"
#include "mozilla/dom/StorageEvent.h" #include "mozilla/dom/StorageEvent.h"
#include "mozilla/dom/SVGZoomEvent.h"
#include "mozilla/dom/TimeEvent.h"
#include "mozilla/dom/TouchEvent.h" #include "mozilla/dom/TouchEvent.h"
#include "mozilla/dom/TransitionEvent.h"
#include "mozilla/dom/WheelEvent.h"
#include "mozilla/dom/XULCommandEvent.h"
#include "mozilla/EventDispatcher.h" #include "mozilla/EventDispatcher.h"
#include "mozilla/EventListenerManager.h" #include "mozilla/EventListenerManager.h"
#include "mozilla/InternalMutationEvent.h" #include "mozilla/InternalMutationEvent.h"
@@ -705,85 +720,76 @@ EventDispatcher::DispatchDOMEvent(nsISupports* aTarget,
return NS_ERROR_ILLEGAL_VALUE; return NS_ERROR_ILLEGAL_VALUE;
} }
/* static */ nsresult /* static */ already_AddRefed<dom::Event>
EventDispatcher::CreateEvent(EventTarget* aOwner, EventDispatcher::CreateEvent(EventTarget* aOwner,
nsPresContext* aPresContext, nsPresContext* aPresContext,
WidgetEvent* aEvent, WidgetEvent* aEvent,
const nsAString& aEventType, const nsAString& aEventType)
nsIDOMEvent** aDOMEvent)
{ {
*aDOMEvent = nullptr;
if (aEvent) { if (aEvent) {
switch(aEvent->mClass) { switch(aEvent->mClass) {
case eMutationEventClass: case eMutationEventClass:
return NS_NewDOMMutationEvent(aDOMEvent, aOwner, aPresContext, return NS_NewDOMMutationEvent(aOwner, aPresContext,
aEvent->AsMutationEvent()); aEvent->AsMutationEvent());
case eGUIEventClass: case eGUIEventClass:
case eScrollPortEventClass: case eScrollPortEventClass:
case eUIEventClass: case eUIEventClass:
return NS_NewDOMUIEvent(aDOMEvent, aOwner, aPresContext, return NS_NewDOMUIEvent(aOwner, aPresContext, aEvent->AsGUIEvent());
aEvent->AsGUIEvent());
case eScrollAreaEventClass: case eScrollAreaEventClass:
return NS_NewDOMScrollAreaEvent(aDOMEvent, aOwner, aPresContext, return NS_NewDOMScrollAreaEvent(aOwner, aPresContext,
aEvent->AsScrollAreaEvent()); aEvent->AsScrollAreaEvent());
case eKeyboardEventClass: case eKeyboardEventClass:
return NS_NewDOMKeyboardEvent(aDOMEvent, aOwner, aPresContext, return NS_NewDOMKeyboardEvent(aOwner, aPresContext,
aEvent->AsKeyboardEvent()); aEvent->AsKeyboardEvent());
case eBeforeAfterKeyboardEventClass: case eBeforeAfterKeyboardEventClass:
return NS_NewDOMBeforeAfterKeyboardEvent(aDOMEvent, aOwner, aPresContext, return NS_NewDOMBeforeAfterKeyboardEvent(aOwner, aPresContext,
aEvent->AsBeforeAfterKeyboardEvent()); aEvent->AsBeforeAfterKeyboardEvent());
case eCompositionEventClass: case eCompositionEventClass:
return NS_NewDOMCompositionEvent(aDOMEvent, aOwner, aPresContext, return NS_NewDOMCompositionEvent(aOwner, aPresContext,
aEvent->AsCompositionEvent()); aEvent->AsCompositionEvent());
case eMouseEventClass: case eMouseEventClass:
return NS_NewDOMMouseEvent(aDOMEvent, aOwner, aPresContext, return NS_NewDOMMouseEvent(aOwner, aPresContext, aEvent->AsMouseEvent());
aEvent->AsMouseEvent());
case eFocusEventClass: case eFocusEventClass:
return NS_NewDOMFocusEvent(aDOMEvent, aOwner, aPresContext, return NS_NewDOMFocusEvent(aOwner, aPresContext, aEvent->AsFocusEvent());
aEvent->AsFocusEvent());
case eMouseScrollEventClass: case eMouseScrollEventClass:
return NS_NewDOMMouseScrollEvent(aDOMEvent, aOwner, aPresContext, return NS_NewDOMMouseScrollEvent(aOwner, aPresContext,
aEvent->AsMouseScrollEvent()); aEvent->AsMouseScrollEvent());
case eWheelEventClass: case eWheelEventClass:
return NS_NewDOMWheelEvent(aDOMEvent, aOwner, aPresContext, return NS_NewDOMWheelEvent(aOwner, aPresContext, aEvent->AsWheelEvent());
aEvent->AsWheelEvent());
case eEditorInputEventClass: case eEditorInputEventClass:
return NS_NewDOMInputEvent(aDOMEvent, aOwner, aPresContext, return NS_NewDOMInputEvent(aOwner, aPresContext,
aEvent->AsEditorInputEvent()); aEvent->AsEditorInputEvent());
case eDragEventClass: case eDragEventClass:
return NS_NewDOMDragEvent(aDOMEvent, aOwner, aPresContext, return NS_NewDOMDragEvent(aOwner, aPresContext, aEvent->AsDragEvent());
aEvent->AsDragEvent());
case eClipboardEventClass: case eClipboardEventClass:
return NS_NewDOMClipboardEvent(aDOMEvent, aOwner, aPresContext, return NS_NewDOMClipboardEvent(aOwner, aPresContext,
aEvent->AsClipboardEvent()); aEvent->AsClipboardEvent());
case eSVGZoomEventClass: case eSVGZoomEventClass:
return NS_NewDOMSVGZoomEvent(aDOMEvent, aOwner, aPresContext, return NS_NewDOMSVGZoomEvent(aOwner, aPresContext,
aEvent->AsSVGZoomEvent()); aEvent->AsSVGZoomEvent());
case eSMILTimeEventClass: case eSMILTimeEventClass:
return NS_NewDOMTimeEvent(aDOMEvent, aOwner, aPresContext, return NS_NewDOMTimeEvent(aOwner, aPresContext,
aEvent->AsSMILTimeEvent()); aEvent->AsSMILTimeEvent());
case eCommandEventClass: case eCommandEventClass:
return NS_NewDOMCommandEvent(aDOMEvent, aOwner, aPresContext, return NS_NewDOMCommandEvent(aOwner, aPresContext,
aEvent->AsCommandEvent()); aEvent->AsCommandEvent());
case eSimpleGestureEventClass: case eSimpleGestureEventClass:
return NS_NewDOMSimpleGestureEvent(aDOMEvent, aOwner, aPresContext, return NS_NewDOMSimpleGestureEvent(aOwner, aPresContext,
aEvent->AsSimpleGestureEvent()); aEvent->AsSimpleGestureEvent());
case ePointerEventClass: case ePointerEventClass:
return NS_NewDOMPointerEvent(aDOMEvent, aOwner, aPresContext, return NS_NewDOMPointerEvent(aOwner, aPresContext,
aEvent->AsPointerEvent()); aEvent->AsPointerEvent());
case eTouchEventClass: case eTouchEventClass:
return NS_NewDOMTouchEvent(aDOMEvent, aOwner, aPresContext, return NS_NewDOMTouchEvent(aOwner, aPresContext, aEvent->AsTouchEvent());
aEvent->AsTouchEvent());
case eTransitionEventClass: case eTransitionEventClass:
return NS_NewDOMTransitionEvent(aDOMEvent, aOwner, aPresContext, return NS_NewDOMTransitionEvent(aOwner, aPresContext,
aEvent->AsTransitionEvent()); aEvent->AsTransitionEvent());
case eAnimationEventClass: case eAnimationEventClass:
return NS_NewDOMAnimationEvent(aDOMEvent, aOwner, aPresContext, return NS_NewDOMAnimationEvent(aOwner, aPresContext,
aEvent->AsAnimationEvent()); aEvent->AsAnimationEvent());
default: default:
// For all other types of events, create a vanilla event object. // For all other types of events, create a vanilla event object.
return NS_NewDOMEvent(aDOMEvent, aOwner, aPresContext, aEvent); return NS_NewDOMEvent(aOwner, aPresContext, aEvent);
} }
} }
@@ -792,106 +798,94 @@ EventDispatcher::CreateEvent(EventTarget* aOwner,
if (aEventType.LowerCaseEqualsLiteral("mouseevent") || if (aEventType.LowerCaseEqualsLiteral("mouseevent") ||
aEventType.LowerCaseEqualsLiteral("mouseevents") || aEventType.LowerCaseEqualsLiteral("mouseevents") ||
aEventType.LowerCaseEqualsLiteral("popupevents")) aEventType.LowerCaseEqualsLiteral("popupevents"))
return NS_NewDOMMouseEvent(aDOMEvent, aOwner, aPresContext, nullptr); return NS_NewDOMMouseEvent(aOwner, aPresContext, nullptr);
if (aEventType.LowerCaseEqualsLiteral("mousescrollevents")) if (aEventType.LowerCaseEqualsLiteral("mousescrollevents"))
return NS_NewDOMMouseScrollEvent(aDOMEvent, aOwner, aPresContext, nullptr); return NS_NewDOMMouseScrollEvent(aOwner, aPresContext, nullptr);
if (aEventType.LowerCaseEqualsLiteral("dragevent") || if (aEventType.LowerCaseEqualsLiteral("dragevent") ||
aEventType.LowerCaseEqualsLiteral("dragevents")) aEventType.LowerCaseEqualsLiteral("dragevents"))
return NS_NewDOMDragEvent(aDOMEvent, aOwner, aPresContext, nullptr); return NS_NewDOMDragEvent(aOwner, aPresContext, nullptr);
if (aEventType.LowerCaseEqualsLiteral("keyboardevent") || if (aEventType.LowerCaseEqualsLiteral("keyboardevent") ||
aEventType.LowerCaseEqualsLiteral("keyevents")) aEventType.LowerCaseEqualsLiteral("keyevents"))
return NS_NewDOMKeyboardEvent(aDOMEvent, aOwner, aPresContext, nullptr); return NS_NewDOMKeyboardEvent(aOwner, aPresContext, nullptr);
if (aEventType.LowerCaseEqualsLiteral("compositionevent") || if (aEventType.LowerCaseEqualsLiteral("compositionevent") ||
aEventType.LowerCaseEqualsLiteral("textevent") || aEventType.LowerCaseEqualsLiteral("textevent") ||
aEventType.LowerCaseEqualsLiteral("textevents")) { aEventType.LowerCaseEqualsLiteral("textevents")) {
return NS_NewDOMCompositionEvent(aDOMEvent, aOwner, aPresContext, nullptr); return NS_NewDOMCompositionEvent(aOwner, aPresContext, nullptr);
} }
if (aEventType.LowerCaseEqualsLiteral("mutationevent") || if (aEventType.LowerCaseEqualsLiteral("mutationevent") ||
aEventType.LowerCaseEqualsLiteral("mutationevents")) aEventType.LowerCaseEqualsLiteral("mutationevents"))
return NS_NewDOMMutationEvent(aDOMEvent, aOwner, aPresContext, nullptr); return NS_NewDOMMutationEvent(aOwner, aPresContext, nullptr);
if (aEventType.LowerCaseEqualsLiteral("deviceorientationevent")) { if (aEventType.LowerCaseEqualsLiteral("deviceorientationevent")) {
DeviceOrientationEventInit init; DeviceOrientationEventInit init;
nsRefPtr<DeviceOrientationEvent> event = return DeviceOrientationEvent::Constructor(aOwner, EmptyString(), init);
DeviceOrientationEvent::Constructor(aOwner, EmptyString(), init);
event.forget(aDOMEvent);
return NS_OK;
} }
if (aEventType.LowerCaseEqualsLiteral("devicemotionevent")) if (aEventType.LowerCaseEqualsLiteral("devicemotionevent"))
return NS_NewDOMDeviceMotionEvent(aDOMEvent, aOwner, aPresContext, nullptr); return NS_NewDOMDeviceMotionEvent(aOwner, aPresContext, nullptr);
if (aEventType.LowerCaseEqualsLiteral("uievent") || if (aEventType.LowerCaseEqualsLiteral("uievent") ||
aEventType.LowerCaseEqualsLiteral("uievents")) aEventType.LowerCaseEqualsLiteral("uievents"))
return NS_NewDOMUIEvent(aDOMEvent, aOwner, aPresContext, nullptr); return NS_NewDOMUIEvent(aOwner, aPresContext, nullptr);
if (aEventType.LowerCaseEqualsLiteral("event") || if (aEventType.LowerCaseEqualsLiteral("event") ||
aEventType.LowerCaseEqualsLiteral("events") || aEventType.LowerCaseEqualsLiteral("events") ||
aEventType.LowerCaseEqualsLiteral("htmlevents") || aEventType.LowerCaseEqualsLiteral("htmlevents") ||
aEventType.LowerCaseEqualsLiteral("svgevent") || aEventType.LowerCaseEqualsLiteral("svgevent") ||
aEventType.LowerCaseEqualsLiteral("svgevents")) aEventType.LowerCaseEqualsLiteral("svgevents"))
return NS_NewDOMEvent(aDOMEvent, aOwner, aPresContext, nullptr); return NS_NewDOMEvent(aOwner, aPresContext, nullptr);
if (aEventType.LowerCaseEqualsLiteral("svgzoomevent") || if (aEventType.LowerCaseEqualsLiteral("svgzoomevent") ||
aEventType.LowerCaseEqualsLiteral("svgzoomevents")) aEventType.LowerCaseEqualsLiteral("svgzoomevents"))
return NS_NewDOMSVGZoomEvent(aDOMEvent, aOwner, aPresContext, nullptr); return NS_NewDOMSVGZoomEvent(aOwner, aPresContext, nullptr);
if (aEventType.LowerCaseEqualsLiteral("timeevent") || if (aEventType.LowerCaseEqualsLiteral("timeevent") ||
aEventType.LowerCaseEqualsLiteral("timeevents")) aEventType.LowerCaseEqualsLiteral("timeevents"))
return NS_NewDOMTimeEvent(aDOMEvent, aOwner, aPresContext, nullptr); return NS_NewDOMTimeEvent(aOwner, aPresContext, nullptr);
if (aEventType.LowerCaseEqualsLiteral("xulcommandevent") || if (aEventType.LowerCaseEqualsLiteral("xulcommandevent") ||
aEventType.LowerCaseEqualsLiteral("xulcommandevents")) aEventType.LowerCaseEqualsLiteral("xulcommandevents"))
return NS_NewDOMXULCommandEvent(aDOMEvent, aOwner, aPresContext, nullptr); return NS_NewDOMXULCommandEvent(aOwner, aPresContext, nullptr);
if (aEventType.LowerCaseEqualsLiteral("commandevent") || if (aEventType.LowerCaseEqualsLiteral("commandevent") ||
aEventType.LowerCaseEqualsLiteral("commandevents")) aEventType.LowerCaseEqualsLiteral("commandevents"))
return NS_NewDOMCommandEvent(aDOMEvent, aOwner, aPresContext, nullptr); return NS_NewDOMCommandEvent(aOwner, aPresContext, nullptr);
if (aEventType.LowerCaseEqualsLiteral("datacontainerevent") || if (aEventType.LowerCaseEqualsLiteral("datacontainerevent") ||
aEventType.LowerCaseEqualsLiteral("datacontainerevents")) aEventType.LowerCaseEqualsLiteral("datacontainerevents"))
return NS_NewDOMDataContainerEvent(aDOMEvent, aOwner, aPresContext, nullptr); return NS_NewDOMDataContainerEvent(aOwner, aPresContext, nullptr);
if (aEventType.LowerCaseEqualsLiteral("messageevent")) if (aEventType.LowerCaseEqualsLiteral("messageevent"))
return NS_NewDOMMessageEvent(aDOMEvent, aOwner, aPresContext, nullptr); return NS_NewDOMMessageEvent(aOwner, aPresContext, nullptr);
if (aEventType.LowerCaseEqualsLiteral("notifypaintevent")) if (aEventType.LowerCaseEqualsLiteral("notifypaintevent"))
return NS_NewDOMNotifyPaintEvent(aDOMEvent, aOwner, aPresContext, nullptr); return NS_NewDOMNotifyPaintEvent(aOwner, aPresContext, nullptr);
if (aEventType.LowerCaseEqualsLiteral("simplegestureevent")) if (aEventType.LowerCaseEqualsLiteral("simplegestureevent"))
return NS_NewDOMSimpleGestureEvent(aDOMEvent, aOwner, aPresContext, nullptr); return NS_NewDOMSimpleGestureEvent(aOwner, aPresContext, nullptr);
if (aEventType.LowerCaseEqualsLiteral("beforeunloadevent")) if (aEventType.LowerCaseEqualsLiteral("beforeunloadevent"))
return NS_NewDOMBeforeUnloadEvent(aDOMEvent, aOwner, aPresContext, nullptr); return NS_NewDOMBeforeUnloadEvent(aOwner, aPresContext, nullptr);
// XXXkhuey this is broken // XXXkhuey this is broken
if (aEventType.LowerCaseEqualsLiteral("pagetransition")) { if (aEventType.LowerCaseEqualsLiteral("pagetransition")) {
PageTransitionEventInit init; PageTransitionEventInit init;
nsRefPtr<PageTransitionEvent> event = return PageTransitionEvent::Constructor(aOwner, EmptyString(), init);
PageTransitionEvent::Constructor(aOwner, EmptyString(), init);
event.forget(aDOMEvent);
return NS_OK;
} }
if (aEventType.LowerCaseEqualsLiteral("scrollareaevent")) if (aEventType.LowerCaseEqualsLiteral("scrollareaevent"))
return NS_NewDOMScrollAreaEvent(aDOMEvent, aOwner, aPresContext, nullptr); return NS_NewDOMScrollAreaEvent(aOwner, aPresContext, nullptr);
// XXXkhuey Chrome supports popstateevent here, even though it provides no // XXXkhuey Chrome supports popstateevent here, even though it provides no
// initPopStateEvent method. This is nuts ... but copying it is unlikely to // initPopStateEvent method. This is nuts ... but copying it is unlikely to
// break the web. // break the web.
if (aEventType.LowerCaseEqualsLiteral("popstateevent")) { if (aEventType.LowerCaseEqualsLiteral("popstateevent")) {
AutoJSContext cx; AutoJSContext cx;
RootedDictionary<PopStateEventInit> init(cx); RootedDictionary<PopStateEventInit> init(cx);
nsRefPtr<PopStateEvent> event = return PopStateEvent::Constructor(aOwner, EmptyString(), init);
PopStateEvent::Constructor(aOwner, EmptyString(), init);
event.forget(aDOMEvent);
return NS_OK;
} }
if (aEventType.LowerCaseEqualsLiteral("touchevent") && if (aEventType.LowerCaseEqualsLiteral("touchevent") &&
TouchEvent::PrefEnabled()) TouchEvent::PrefEnabled())
return NS_NewDOMTouchEvent(aDOMEvent, aOwner, aPresContext, nullptr); return NS_NewDOMTouchEvent(aOwner, aPresContext, nullptr);
if (aEventType.LowerCaseEqualsLiteral("hashchangeevent")) { if (aEventType.LowerCaseEqualsLiteral("hashchangeevent")) {
HashChangeEventInit init; HashChangeEventInit init;
nsRefPtr<HashChangeEvent> event = return HashChangeEvent::Constructor(aOwner, EmptyString(), init);
HashChangeEvent::Constructor(aOwner, EmptyString(), init);
event.forget(aDOMEvent);
return NS_OK;
} }
if (aEventType.LowerCaseEqualsLiteral("customevent")) if (aEventType.LowerCaseEqualsLiteral("customevent"))
return NS_NewDOMCustomEvent(aDOMEvent, aOwner, aPresContext, nullptr); return NS_NewDOMCustomEvent(aOwner, aPresContext, nullptr);
if (aEventType.LowerCaseEqualsLiteral("storageevent")) { if (aEventType.LowerCaseEqualsLiteral("storageevent")) {
return NS_NewDOMStorageEvent(aDOMEvent, aOwner); return NS_NewDOMStorageEvent(aOwner);
} }
// NEW EVENT TYPES SHOULD NOT BE ADDED HERE; THEY SHOULD USE ONLY EVENT // NEW EVENT TYPES SHOULD NOT BE ADDED HERE; THEY SHOULD USE ONLY EVENT
// CONSTRUCTORS // CONSTRUCTORS
return NS_ERROR_DOM_NOT_SUPPORTED_ERR; return nullptr;
} }
} // namespace mozilla } // namespace mozilla

12
dom/events/EventDispatcher.h
View File

@@ -23,6 +23,7 @@ template<class E> class nsCOMArray;
namespace mozilla { namespace mozilla {
namespace dom { namespace dom {
class Event;
class EventTarget; class EventTarget;
} // namespace dom } // namespace dom
@@ -272,13 +273,12 @@ public:
nsEventStatus* aEventStatus); nsEventStatus* aEventStatus);
/** /**
* Creates a DOM Event. * Creates a DOM Event. Returns null if the event type is unsupported.
*/ */
static nsresult CreateEvent(dom::EventTarget* aOwner, static already_AddRefed<dom::Event> CreateEvent(dom::EventTarget* aOwner,
nsPresContext* aPresContext, nsPresContext* aPresContext,
WidgetEvent* aEvent, WidgetEvent* aEvent,
const nsAString& aEventType, const nsAString& aEventType);
nsIDOMEvent** aDOMEvent);
/** /**
* Called at shutting down. * Called at shutting down.

6
dom/events/EventListenerManager.cpp
View File

@@ -1109,8 +1109,10 @@ EventListenerManager::HandleEventInternal(nsPresContext* aPresContext,
// This is tiny bit slow, but happens only once per event. // This is tiny bit slow, but happens only once per event.
nsCOMPtr<EventTarget> et = nsCOMPtr<EventTarget> et =
do_QueryInterface(aEvent->originalTarget); do_QueryInterface(aEvent->originalTarget);
EventDispatcher::CreateEvent(et, aPresContext, nsRefPtr<Event> event = EventDispatcher::CreateEvent(et, aPresContext,
aEvent, EmptyString(), aDOMEvent); aEvent,
EmptyString());
event.forget(aDOMEvent);
} }
if (*aDOMEvent) { if (*aDOMEvent) {
if (!aEvent->currentTarget) { if (!aEvent->currentTarget) {

17
dom/events/EventStateManager.cpp
View File

@@ -16,6 +16,7 @@
#include "mozilla/TextEvents.h" #include "mozilla/TextEvents.h"
#include "mozilla/TouchEvents.h" #include "mozilla/TouchEvents.h"
#include "mozilla/dom/ContentChild.h" #include "mozilla/dom/ContentChild.h"
#include "mozilla/dom/DragEvent.h"
#include "mozilla/dom/Event.h" #include "mozilla/dom/Event.h"
#include "mozilla/dom/TabParent.h" #include "mozilla/dom/TabParent.h"
#include "mozilla/dom/UIEvent.h" #include "mozilla/dom/UIEvent.h"
@@ -54,7 +55,6 @@
#include "nsIObserverService.h" #include "nsIObserverService.h"
#include "nsIDocShell.h" #include "nsIDocShell.h"
#include "nsIDOMWheelEvent.h" #include "nsIDOMWheelEvent.h"
#include "nsIDOMDragEvent.h"
#include "nsIDOMUIEvent.h" #include "nsIDOMUIEvent.h"
#include "nsIMozBrowserFrame.h" #include "nsIMozBrowserFrame.h"
@@ -1881,13 +1881,8 @@ EventStateManager::DoDefaultDragStart(nsPresContext* aPresContext,
// XXXndeakin don't really want to create a new drag DOM event // XXXndeakin don't really want to create a new drag DOM event
// here, but we need something to pass to the InvokeDragSession // here, but we need something to pass to the InvokeDragSession
// methods. // methods.
nsCOMPtr<nsIDOMEvent> domEvent; nsRefPtr<DragEvent> event =
NS_NewDOMDragEvent(getter_AddRefs(domEvent), dragTarget, NS_NewDOMDragEvent(dragTarget, aPresContext, aDragEvent);
aPresContext, aDragEvent);
nsCOMPtr<nsIDOMDragEvent> domDragEvent = do_QueryInterface(domEvent);
// if creating a drag event failed, starting a drag session will
// just fail.
// Use InvokeDragSessionWithSelection if a selection is being dragged, // Use InvokeDragSessionWithSelection if a selection is being dragged,
// such that the image can be generated from the selected text. However, // such that the image can be generated from the selected text. However,
@@ -1895,8 +1890,7 @@ EventStateManager::DoDefaultDragStart(nsPresContext* aPresContext,
// other than a selection is being dragged. // other than a selection is being dragged.
if (!dragImage && aSelection) { if (!dragImage && aSelection) {
dragService->InvokeDragSessionWithSelection(aSelection, transArray, dragService->InvokeDragSessionWithSelection(aSelection, transArray,
action, domDragEvent, action, event, aDataTransfer);
aDataTransfer);
} }
else { else {
// if dragging within a XUL tree and no custom drag image was // if dragging within a XUL tree and no custom drag image was
@@ -1922,8 +1916,7 @@ EventStateManager::DoDefaultDragStart(nsPresContext* aPresContext,
region, action, region, action,
dragImage ? dragImage->AsDOMNode() : dragImage ? dragImage->AsDOMNode() :
nullptr, nullptr,
imageX, imageX, imageY, event,
imageY, domDragEvent,
aDataTransfer); aDataTransfer);
} }

11
dom/events/FocusEvent.cpp
View File

@@ -77,14 +77,11 @@ FocusEvent::Constructor(const GlobalObject& aGlobal,
using namespace mozilla; using namespace mozilla;
using namespace mozilla::dom; using namespace mozilla::dom;
nsresult already_AddRefed<FocusEvent>
NS_NewDOMFocusEvent(nsIDOMEvent** aInstancePtrResult, NS_NewDOMFocusEvent(EventTarget* aOwner,
EventTarget* aOwner,
nsPresContext* aPresContext, nsPresContext* aPresContext,
InternalFocusEvent* aEvent) InternalFocusEvent* aEvent)
{ {
FocusEvent* it = new FocusEvent(aOwner, aPresContext, aEvent); nsRefPtr<FocusEvent> it = new FocusEvent(aOwner, aPresContext, aEvent);
NS_ADDREF(it); return it.forget();
*aInstancePtrResult = static_cast<Event*>(it);
return NS_OK;
} }

5
dom/events/FocusEvent.h
View File

@@ -53,4 +53,9 @@ protected:
} // namespace dom } // namespace dom
} // namespace mozilla } // namespace mozilla
already_AddRefed<mozilla::dom::FocusEvent>
NS_NewDOMFocusEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::InternalFocusEvent* aEvent);
#endif // mozilla_dom_FocusEvent_h_ #endif // mozilla_dom_FocusEvent_h_

11
dom/events/InputEvent.cpp
View File

@@ -63,14 +63,11 @@ InputEvent::Constructor(const GlobalObject& aGlobal,
using namespace mozilla; using namespace mozilla;
using namespace mozilla::dom; using namespace mozilla::dom;
nsresult already_AddRefed<InputEvent>
NS_NewDOMInputEvent(nsIDOMEvent** aInstancePtrResult, NS_NewDOMInputEvent(EventTarget* aOwner,
EventTarget* aOwner,
nsPresContext* aPresContext, nsPresContext* aPresContext,
InternalEditorInputEvent* aEvent) InternalEditorInputEvent* aEvent)
{ {
InputEvent* it = new InputEvent(aOwner, aPresContext, aEvent); nsRefPtr<InputEvent> it = new InputEvent(aOwner, aPresContext, aEvent);
NS_ADDREF(it); return it.forget();
*aInstancePtrResult = static_cast<Event*>(it);
return NS_OK;
} }

5
dom/events/InputEvent.h
View File

@@ -46,4 +46,9 @@ protected:
} // namespace dom } // namespace dom
} // namespace mozilla } // namespace mozilla
already_AddRefed<mozilla::dom::InputEvent>
NS_NewDOMInputEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::InternalEditorInputEvent* aEvent);
#endif // mozilla_dom_InputEvent_h_ #endif // mozilla_dom_InputEvent_h_

11
dom/events/KeyboardEvent.cpp
View File

@@ -309,14 +309,11 @@ KeyboardEvent::InitKeyEvent(const nsAString& aType,
using namespace mozilla; using namespace mozilla;
using namespace mozilla::dom; using namespace mozilla::dom;
nsresult already_AddRefed<KeyboardEvent>
NS_NewDOMKeyboardEvent(nsIDOMEvent** aInstancePtrResult, NS_NewDOMKeyboardEvent(EventTarget* aOwner,
EventTarget* aOwner,
nsPresContext* aPresContext, nsPresContext* aPresContext,
WidgetKeyboardEvent* aEvent) WidgetKeyboardEvent* aEvent)
{ {
KeyboardEvent* it = new KeyboardEvent(aOwner, aPresContext, aEvent); nsRefPtr<KeyboardEvent> it = new KeyboardEvent(aOwner, aPresContext, aEvent);
NS_ADDREF(it); return it.forget();
*aInstancePtrResult = static_cast<Event*>(it);
return NS_OK;
} }

5
dom/events/KeyboardEvent.h
View File

@@ -93,4 +93,9 @@ private:
} // namespace dom } // namespace dom
} // namespace mozilla } // namespace mozilla
already_AddRefed<mozilla::dom::KeyboardEvent>
NS_NewDOMKeyboardEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetKeyboardEvent* aEvent);
#endif // mozilla_dom_KeyboardEvent_h_ #endif // mozilla_dom_KeyboardEvent_h_

13
dom/events/MessageEvent.cpp
View File

@@ -172,7 +172,7 @@ MessageEvent::Constructor(EventTarget* aEventTarget,
ports.AppendElement(aParam.mPorts.Value().Value()[i].get()); ports.AppendElement(aParam.mPorts.Value().Value()[i].get());
} }
event->mPorts = new MessagePortList(static_cast<EventBase*>(event), ports); event->mPorts = new MessagePortList(static_cast<Event*>(event), ports);
} }
return event.forget(); return event.forget();
@@ -224,14 +224,11 @@ MessageEvent::SetSource(mozilla::dom::workers::ServiceWorkerClient* aClient)
using namespace mozilla; using namespace mozilla;
using namespace mozilla::dom; using namespace mozilla::dom;
nsresult already_AddRefed<MessageEvent>
NS_NewDOMMessageEvent(nsIDOMEvent** aInstancePtrResult, NS_NewDOMMessageEvent(EventTarget* aOwner,
EventTarget* aOwner,
nsPresContext* aPresContext, nsPresContext* aPresContext,
WidgetEvent* aEvent) WidgetEvent* aEvent)
{ {
MessageEvent* it = new MessageEvent(aOwner, aPresContext, aEvent); nsRefPtr<MessageEvent> it = new MessageEvent(aOwner, aPresContext, aEvent);
NS_ADDREF(it); return it.forget();
*aInstancePtrResult = static_cast<Event*>(it);
return NS_OK;
} }

5
dom/events/MessageEvent.h
View File

@@ -102,4 +102,9 @@ private:
} // namespace dom } // namespace dom
} // namespace mozilla } // namespace mozilla
already_AddRefed<mozilla::dom::MessageEvent>
NS_NewDOMMessageEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetEvent* aEvent);
#endif // mozilla_dom_MessageEvent_h_ #endif // mozilla_dom_MessageEvent_h_

11
dom/events/MouseEvent.cpp
View File

@@ -504,14 +504,11 @@ MouseEvent::GetMozInputSource(uint16_t* aInputSource)
using namespace mozilla; using namespace mozilla;
using namespace mozilla::dom; using namespace mozilla::dom;
nsresult already_AddRefed<MouseEvent>
NS_NewDOMMouseEvent(nsIDOMEvent** aInstancePtrResult, NS_NewDOMMouseEvent(EventTarget* aOwner,
EventTarget* aOwner,
nsPresContext* aPresContext, nsPresContext* aPresContext,
WidgetMouseEvent* aEvent) WidgetMouseEvent* aEvent)
{ {
MouseEvent* it = new MouseEvent(aOwner, aPresContext, aEvent); nsRefPtr<MouseEvent> it = new MouseEvent(aOwner, aPresContext, aEvent);
NS_ADDREF(it); return it.forget();
*aInstancePtrResult = static_cast<Event*>(it);
return NS_OK;
} }

5
dom/events/MouseEvent.h
View File

@@ -132,4 +132,9 @@ protected:
NS_FORWARD_NSIDOMMOUSEEVENT(MouseEvent::) \ NS_FORWARD_NSIDOMMOUSEEVENT(MouseEvent::) \
NS_FORWARD_TO_UIEVENT NS_FORWARD_TO_UIEVENT
already_AddRefed<mozilla::dom::MouseEvent>
NS_NewDOMMouseEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetMouseEvent* aEvent);
#endif // mozilla_dom_MouseEvent_h_ #endif // mozilla_dom_MouseEvent_h_

12
dom/events/MouseScrollEvent.cpp
View File

@@ -88,14 +88,12 @@ MouseScrollEvent::Axis()
using namespace mozilla; using namespace mozilla;
using namespace dom; using namespace dom;
nsresult already_AddRefed<MouseScrollEvent>
NS_NewDOMMouseScrollEvent(nsIDOMEvent** aInstancePtrResult, NS_NewDOMMouseScrollEvent(EventTarget* aOwner,
EventTarget* aOwner,
nsPresContext* aPresContext, nsPresContext* aPresContext,
WidgetMouseScrollEvent* aEvent) WidgetMouseScrollEvent* aEvent)
{ {
MouseScrollEvent* it = new MouseScrollEvent(aOwner, aPresContext, aEvent); nsRefPtr<MouseScrollEvent> it =
NS_ADDREF(it); new MouseScrollEvent(aOwner, aPresContext, aEvent);
*aInstancePtrResult = static_cast<Event*>(it); return it.forget();
return NS_OK;
} }

5
dom/events/MouseScrollEvent.h
View File

@@ -59,4 +59,9 @@ protected:
} // namespace dom } // namespace dom
} // namespace mozilla } // namespace mozilla
already_AddRefed<mozilla::dom::MouseScrollEvent>
NS_NewDOMMouseScrollEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetMouseScrollEvent* aEvent);
#endif // mozilla_dom_MouseScrollEvent_h_ #endif // mozilla_dom_MouseScrollEvent_h_

11
dom/events/MutationEvent.cpp
View File

@@ -119,14 +119,11 @@ MutationEvent::InitMutationEvent(const nsAString& aTypeArg,
using namespace mozilla; using namespace mozilla;
using namespace mozilla::dom; using namespace mozilla::dom;
nsresult already_AddRefed<MutationEvent>
NS_NewDOMMutationEvent(nsIDOMEvent** aInstancePtrResult, NS_NewDOMMutationEvent(EventTarget* aOwner,
EventTarget* aOwner,
nsPresContext* aPresContext, nsPresContext* aPresContext,
InternalMutationEvent* aEvent) InternalMutationEvent* aEvent)
{ {
MutationEvent* it = new MutationEvent(aOwner, aPresContext, aEvent); nsRefPtr<MutationEvent> it = new MutationEvent(aOwner, aPresContext, aEvent);
NS_ADDREF(it); return it.forget();
*aInstancePtrResult = static_cast<Event*>(it);
return NS_OK;
} }

5
dom/events/MutationEvent.h
View File

@@ -65,4 +65,9 @@ protected:
} // namespace dom } // namespace dom
} // namespace mozilla } // namespace mozilla
already_AddRefed<mozilla::dom::MutationEvent>
NS_NewDOMMutationEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::InternalMutationEvent* aEvent);
#endif // mozilla_dom_MutationEvent_h_ #endif // mozilla_dom_MutationEvent_h_

14
dom/events/NotifyPaintEvent.cpp
View File

@@ -162,17 +162,15 @@ NotifyPaintEvent::Deserialize(const IPC::Message* aMsg, void** aIter)
using namespace mozilla; using namespace mozilla;
using namespace mozilla::dom; using namespace mozilla::dom;
nsresult already_AddRefed<NotifyPaintEvent>
NS_NewDOMNotifyPaintEvent(nsIDOMEvent** aInstancePtrResult, NS_NewDOMNotifyPaintEvent(EventTarget* aOwner,
EventTarget* aOwner,
nsPresContext* aPresContext, nsPresContext* aPresContext,
WidgetEvent* aEvent, WidgetEvent* aEvent,
uint32_t aEventType, uint32_t aEventType,
nsInvalidateRequestList* aInvalidateRequests) nsInvalidateRequestList* aInvalidateRequests)
{ {
NotifyPaintEvent* it = new NotifyPaintEvent(aOwner, aPresContext, aEvent, nsRefPtr<NotifyPaintEvent> it =
aEventType, aInvalidateRequests); new NotifyPaintEvent(aOwner, aPresContext, aEvent, aEventType,
NS_ADDREF(it); aInvalidateRequests);
*aInstancePtrResult = static_cast<Event*>(it); return it.forget();
return NS_OK;
} }

8
dom/events/NotifyPaintEvent.h
View File

@@ -67,4 +67,12 @@ private:
} // namespace dom } // namespace dom
} // namespace mozilla } // namespace mozilla
// This empties aInvalidateRequests.
already_AddRefed<mozilla::dom::NotifyPaintEvent>
NS_NewDOMNotifyPaintEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetEvent* aEvent,
uint32_t aEventType = 0,
nsInvalidateRequestList* aInvalidateRequests = nullptr);
#endif // mozilla_dom_NotifyPaintEvent_h_ #endif // mozilla_dom_NotifyPaintEvent_h_

11
dom/events/PointerEvent.cpp
View File

@@ -164,14 +164,11 @@ PointerEvent::IsPrimary()
using namespace mozilla; using namespace mozilla;
using namespace mozilla::dom; using namespace mozilla::dom;
nsresult already_AddRefed<PointerEvent>
NS_NewDOMPointerEvent(nsIDOMEvent** aInstancePtrResult, NS_NewDOMPointerEvent(EventTarget* aOwner,
EventTarget* aOwner,
nsPresContext* aPresContext, nsPresContext* aPresContext,
WidgetPointerEvent *aEvent) WidgetPointerEvent *aEvent)
{ {
PointerEvent *it = new PointerEvent(aOwner, aPresContext, aEvent); nsRefPtr<PointerEvent> it = new PointerEvent(aOwner, aPresContext, aEvent);
NS_ADDREF(it); return it.forget();
*aInstancePtrResult = static_cast<Event*>(it);
return NS_OK;
} }

5
dom/events/PointerEvent.h
View File

@@ -55,4 +55,9 @@ void ConvertPointerTypeToString(uint16_t aPointerTypeSrc, nsAString& aPointerTyp
} // namespace dom } // namespace dom
} // namespace mozilla } // namespace mozilla
already_AddRefed<mozilla::dom::PointerEvent>
NS_NewDOMPointerEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetPointerEvent* aEvent);
#endif // mozilla_dom_PointerEvent_h_ #endif // mozilla_dom_PointerEvent_h_

10
dom/events/ScrollAreaEvent.cpp
View File

@@ -100,12 +100,12 @@ ScrollAreaEvent::Deserialize(const IPC::Message* aMsg, void** aIter)
using namespace mozilla; using namespace mozilla;
using namespace mozilla::dom; using namespace mozilla::dom;
nsresult already_AddRefed<ScrollAreaEvent>
NS_NewDOMScrollAreaEvent(nsIDOMEvent** aInstancePtrResult, NS_NewDOMScrollAreaEvent(EventTarget* aOwner,
EventTarget* aOwner,
nsPresContext* aPresContext, nsPresContext* aPresContext,
InternalScrollAreaEvent* aEvent) InternalScrollAreaEvent* aEvent)
{ {
ScrollAreaEvent* ev = new ScrollAreaEvent(aOwner, aPresContext, aEvent); nsRefPtr<ScrollAreaEvent> ev =
return CallQueryInterface(ev, aInstancePtrResult); new ScrollAreaEvent(aOwner, aPresContext, aEvent);
return ev.forget();
} }

5
dom/events/ScrollAreaEvent.h
View File

@@ -86,4 +86,9 @@ protected:
} // namespace dom } // namespace dom
} // namespace mozilla } // namespace mozilla
already_AddRefed<mozilla::dom::ScrollAreaEvent>
NS_NewDOMScrollAreaEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::InternalScrollAreaEvent* aEvent);
#endif // mozilla_dom_ScrollAreaEvent_h_ #endif // mozilla_dom_ScrollAreaEvent_h_

12
dom/events/SimpleGestureEvent.cpp
View File

@@ -146,14 +146,12 @@ SimpleGestureEvent::InitSimpleGestureEvent(const nsAString& aTypeArg,
using namespace mozilla; using namespace mozilla;
using namespace mozilla::dom; using namespace mozilla::dom;
nsresult already_AddRefed<SimpleGestureEvent>
NS_NewDOMSimpleGestureEvent(nsIDOMEvent** aInstancePtrResult, NS_NewDOMSimpleGestureEvent(EventTarget* aOwner,
EventTarget* aOwner,
nsPresContext* aPresContext, nsPresContext* aPresContext,
WidgetSimpleGestureEvent* aEvent) WidgetSimpleGestureEvent* aEvent)
{ {
SimpleGestureEvent* it = new SimpleGestureEvent(aOwner, aPresContext, aEvent); nsRefPtr<SimpleGestureEvent> it =
NS_ADDREF(it); new SimpleGestureEvent(aOwner, aPresContext, aEvent);
*aInstancePtrResult = static_cast<Event*>(it); return it.forget();
return NS_OK;
} }

5
dom/events/SimpleGestureEvent.h
View File

@@ -78,4 +78,9 @@ protected:
} // namespace dom } // namespace dom
} // namespace mozilla } // namespace mozilla
already_AddRefed<mozilla::dom::SimpleGestureEvent>
NS_NewDOMSimpleGestureEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetSimpleGestureEvent* aEvent);
#endif // mozilla_dom_SimpleGestureEvent_h_ #endif // mozilla_dom_SimpleGestureEvent_h_

15
dom/events/StorageEvent.cpp
View File

@@ -103,16 +103,15 @@ StorageEvent::InitStorageEvent(const nsAString& aType, bool aCanBubble,
} // namespace dom } // namespace dom
} // namespace mozilla } // namespace mozilla
nsresult using namespace mozilla;
NS_NewDOMStorageEvent(nsIDOMEvent** aDOMEvent, using namespace mozilla::dom;
mozilla::dom::EventTarget* aOwner)
already_AddRefed<StorageEvent>
NS_NewDOMStorageEvent(EventTarget* aOwner)
{ {
nsRefPtr<mozilla::dom::StorageEvent> e = nsRefPtr<StorageEvent> e = new StorageEvent(aOwner);
new mozilla::dom::StorageEvent(aOwner);
e->SetTrusted(e->Init(aOwner)); e->SetTrusted(e->Init(aOwner));
e.forget(aDOMEvent); return e.forget();
return NS_OK;
} }

4
dom/events/StorageEvent.h
View File

@@ -14,8 +14,8 @@
#include "mozilla/dom/StorageEventBinding.h" #include "mozilla/dom/StorageEventBinding.h"
// Helper for EventDispatcher. // Helper for EventDispatcher.
nsresult NS_NewDOMStorageEvent(nsIDOMEvent** aDOMEvent, already_AddRefed<mozilla::dom::StorageEvent>
mozilla::dom::EventTarget* aOwner); NS_NewDOMStorageEvent(mozilla::dom::EventTarget* aOwner);
namespace mozilla { namespace mozilla {
namespace dom { namespace dom {

11
dom/events/TouchEvent.cpp
View File

@@ -238,14 +238,11 @@ TouchEvent::ShiftKey()
using namespace mozilla; using namespace mozilla;
using namespace mozilla::dom; using namespace mozilla::dom;
nsresult already_AddRefed<TouchEvent>
NS_NewDOMTouchEvent(nsIDOMEvent** aInstancePtrResult, NS_NewDOMTouchEvent(EventTarget* aOwner,
EventTarget* aOwner,
nsPresContext* aPresContext, nsPresContext* aPresContext,
WidgetTouchEvent* aEvent) WidgetTouchEvent* aEvent)
{ {
TouchEvent* it = new TouchEvent(aOwner, aPresContext, aEvent); nsRefPtr<TouchEvent> it = new TouchEvent(aOwner, aPresContext, aEvent);
NS_ADDREF(it); return it.forget();
*aInstancePtrResult = static_cast<Event*>(it);
return NS_OK;
} }

5
dom/events/TouchEvent.h
View File

@@ -132,4 +132,9 @@ protected:
} // namespace dom } // namespace dom
} // namespace mozilla } // namespace mozilla
already_AddRefed<mozilla::dom::TouchEvent>
NS_NewDOMTouchEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetTouchEvent* aEvent);
#endif // mozilla_dom_TouchEvent_h_ #endif // mozilla_dom_TouchEvent_h_

12
dom/events/TransitionEvent.cpp
View File

@@ -88,14 +88,12 @@ TransitionEvent::GetPseudoElement(nsAString& aPseudoElement)
using namespace mozilla; using namespace mozilla;
using namespace mozilla::dom; using namespace mozilla::dom;
nsresult already_AddRefed<TransitionEvent>
NS_NewDOMTransitionEvent(nsIDOMEvent** aInstancePtrResult, NS_NewDOMTransitionEvent(EventTarget* aOwner,
EventTarget* aOwner,
nsPresContext* aPresContext, nsPresContext* aPresContext,
InternalTransitionEvent* aEvent) InternalTransitionEvent* aEvent)
{ {
TransitionEvent *it = new TransitionEvent(aOwner, aPresContext, aEvent); nsRefPtr<TransitionEvent> it =
NS_ADDREF(it); new TransitionEvent(aOwner, aPresContext, aEvent);
*aInstancePtrResult = static_cast<Event*>(it); return it.forget();
return NS_OK;
} }

5
dom/events/TransitionEvent.h
View File

@@ -52,4 +52,9 @@ protected:
} // namespace dom } // namespace dom
} // namespace mozilla } // namespace mozilla
already_AddRefed<mozilla::dom::TransitionEvent>
NS_NewDOMTransitionEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::InternalTransitionEvent* aEvent);
#endif // mozilla_dom_TransitionEvent_h_ #endif // mozilla_dom_TransitionEvent_h_

11
dom/events/UIEvent.cpp
View File

@@ -499,14 +499,11 @@ UIEvent::InitModifiers(const EventModifierInit& aParam)
using namespace mozilla; using namespace mozilla;
using namespace mozilla::dom; using namespace mozilla::dom;
nsresult already_AddRefed<UIEvent>
NS_NewDOMUIEvent(nsIDOMEvent** aInstancePtrResult, NS_NewDOMUIEvent(EventTarget* aOwner,
EventTarget* aOwner,
nsPresContext* aPresContext, nsPresContext* aPresContext,
WidgetGUIEvent* aEvent) WidgetGUIEvent* aEvent)
{ {
UIEvent* it = new UIEvent(aOwner, aPresContext, aEvent); nsRefPtr<UIEvent> it = new UIEvent(aOwner, aPresContext, aEvent);
NS_ADDREF(it); return it.forget();
*aInstancePtrResult = static_cast<Event*>(it);
return NS_OK;
} }

5
dom/events/UIEvent.h
View File

@@ -194,4 +194,9 @@ protected:
return UIEvent::Deserialize(aMsg, aIter); \ return UIEvent::Deserialize(aMsg, aIter); \
} }
already_AddRefed<mozilla::dom::UIEvent>
NS_NewDOMUIEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetGUIEvent* aEvent);
#endif // mozilla_dom_UIEvent_h_ #endif // mozilla_dom_UIEvent_h_

11
dom/events/WheelEvent.cpp
View File

@@ -175,14 +175,11 @@ WheelEvent::Constructor(const GlobalObject& aGlobal,
using namespace mozilla; using namespace mozilla;
using namespace mozilla::dom; using namespace mozilla::dom;
nsresult already_AddRefed<WheelEvent>
NS_NewDOMWheelEvent(nsIDOMEvent** aInstancePtrResult, NS_NewDOMWheelEvent(EventTarget* aOwner,
EventTarget* aOwner,
nsPresContext* aPresContext, nsPresContext* aPresContext,
WidgetWheelEvent* aEvent) WidgetWheelEvent* aEvent)
{ {
WheelEvent* it = new WheelEvent(aOwner, aPresContext, aEvent); nsRefPtr<WheelEvent> it = new WheelEvent(aOwner, aPresContext, aEvent);
NS_ADDREF(it); return it.forget();
*aInstancePtrResult = static_cast<Event*>(it);
return NS_OK;
} }

5
dom/events/WheelEvent.h
View File

@@ -60,4 +60,9 @@ private:
} // namespace dom } // namespace dom
} // namespace mozilla } // namespace mozilla
already_AddRefed<mozilla::dom::WheelEvent>
NS_NewDOMWheelEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetWheelEvent* aEvent);
#endif // mozilla_dom_WheelEvent_h_ #endif // mozilla_dom_WheelEvent_h_

12
dom/events/XULCommandEvent.cpp
View File

@@ -129,14 +129,12 @@ XULCommandEvent::InitCommandEvent(const nsAString& aType,
using namespace mozilla; using namespace mozilla;
using namespace mozilla::dom; using namespace mozilla::dom;
nsresult already_AddRefed<XULCommandEvent>
NS_NewDOMXULCommandEvent(nsIDOMEvent** aInstancePtrResult, NS_NewDOMXULCommandEvent(EventTarget* aOwner,
EventTarget* aOwner,
nsPresContext* aPresContext, nsPresContext* aPresContext,
WidgetInputEvent* aEvent) WidgetInputEvent* aEvent)
{ {
XULCommandEvent* it = new XULCommandEvent(aOwner, aPresContext, aEvent); nsRefPtr<XULCommandEvent> it =
NS_ADDREF(it); new XULCommandEvent(aOwner, aPresContext, aEvent);
*aInstancePtrResult = static_cast<Event*>(it); return it.forget();
return NS_OK;
} }

5
dom/events/XULCommandEvent.h
View File

@@ -71,4 +71,9 @@ protected:
} // namespace dom } // namespace dom
} // namespace mozilla } // namespace mozilla
already_AddRefed<mozilla::dom::XULCommandEvent>
NS_NewDOMXULCommandEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetInputEvent* aEvent);
#endif // mozilla_dom_XULCommandEvent_h_ #endif // mozilla_dom_XULCommandEvent_h_

1
dom/events/moz.build
View File

@@ -135,6 +135,7 @@ LOCAL_INCLUDES += [
'/dom/html', '/dom/html',
'/dom/settings', '/dom/settings',
'/dom/storage', '/dom/storage',
'/dom/svg',
'/dom/workers', '/dom/workers',
'/dom/xml', '/dom/xml',
'/dom/xul', '/dom/xul',

14
dom/html/HTMLInputElement.cpp
View File

@@ -5403,17 +5403,13 @@ FireEventForAccessibility(nsIDOMHTMLInputElement* aTarget,
nsPresContext* aPresContext, nsPresContext* aPresContext,
const nsAString& aEventType) const nsAString& aEventType)
{ {
nsCOMPtr<nsIDOMEvent> event;
nsCOMPtr<mozilla::dom::Element> element = do_QueryInterface(aTarget); nsCOMPtr<mozilla::dom::Element> element = do_QueryInterface(aTarget);
if (NS_SUCCEEDED(EventDispatcher::CreateEvent(element, aPresContext, nullptr, nsRefPtr<Event> event = NS_NewDOMEvent(element, aPresContext, nullptr);
NS_LITERAL_STRING("Events"), event->InitEvent(aEventType, true, true);
getter_AddRefs(event)))) { event->SetTrusted(true);
event->InitEvent(aEventType, true, true);
event->SetTrusted(true);
EventDispatcher::DispatchDOMEvent(aTarget, nullptr, event, aPresContext, EventDispatcher::DispatchDOMEvent(aTarget, nullptr, event, aPresContext,
nullptr); nullptr);
}
return NS_OK; return NS_OK;
} }

159
dom/interfaces/events/nsIDOMEvent.idl
View File

@@ -215,162 +215,3 @@ interface nsIDOMEvent : nsISupports
[notxpcom] DOMEventPtr InternalDOMEvent(); [notxpcom] DOMEventPtr InternalDOMEvent();
[noscript] void stopCrossProcessForwarding(); [noscript] void stopCrossProcessForwarding();
}; };
%{C++
nsresult
NS_NewDOMEvent(nsIDOMEvent** aInstancePtrResult,
mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetEvent* aEvent);
nsresult
NS_NewDOMDataContainerEvent(nsIDOMEvent** aInstancePtrResult,
mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetEvent* aEvent);
nsresult
NS_NewDOMUIEvent(nsIDOMEvent** aInstancePtrResult,
mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetGUIEvent* aEvent);
nsresult
NS_NewDOMMouseEvent(nsIDOMEvent** aInstancePtrResult,
mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetMouseEvent* aEvent);
nsresult
NS_NewDOMFocusEvent(nsIDOMEvent** aInstancePtrResult,
mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::InternalFocusEvent* aEvent);
nsresult
NS_NewDOMMouseScrollEvent(nsIDOMEvent** aInstancePtrResult,
mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetMouseScrollEvent* aEvent);
nsresult
NS_NewDOMWheelEvent(nsIDOMEvent** aInstancePtrResult,
mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetWheelEvent* aEvent);
nsresult
NS_NewDOMDragEvent(nsIDOMEvent** aInstancePtrResult,
mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetDragEvent* aEvent);
nsresult
NS_NewDOMClipboardEvent(nsIDOMEvent** aInstancePtrResult,
mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::InternalClipboardEvent* aEvent);
nsresult
NS_NewDOMInputEvent(nsIDOMEvent** aInstancePtrResult,
mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::InternalEditorInputEvent* aEvent);
nsresult
NS_NewDOMKeyboardEvent(nsIDOMEvent** aInstancePtrResult,
mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetKeyboardEvent* aEvent);
nsresult
NS_NewDOMBeforeAfterKeyboardEvent(nsIDOMEvent** aInstancePtrResult,
mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::InternalBeforeAfterKeyboardEvent* aEvent);
nsresult
NS_NewDOMCompositionEvent(nsIDOMEvent** aInstancePtrResult,
mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetCompositionEvent* aEvent);
nsresult
NS_NewDOMMutationEvent(nsIDOMEvent** aResult,
mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::InternalMutationEvent* aEvent);
nsresult
NS_NewDOMDeviceMotionEvent(nsIDOMEvent** aResult,
mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetEvent* aEvent);
nsresult
NS_NewDOMBeforeUnloadEvent(nsIDOMEvent** aResult,
mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetEvent* aEvent);
nsresult
NS_NewDOMSVGEvent(nsIDOMEvent** aResult,
mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetEvent* aEvent);
nsresult
NS_NewDOMSVGZoomEvent(nsIDOMEvent** aResult,
mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::InternalSVGZoomEvent* aEvent);
nsresult
NS_NewDOMTimeEvent(nsIDOMEvent** aResult,
mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::InternalSMILTimeEvent* aEvent);
nsresult
NS_NewDOMXULCommandEvent(nsIDOMEvent** aResult,
mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetInputEvent* aEvent);
nsresult
NS_NewDOMCommandEvent(nsIDOMEvent** aInstancePtrResult,
mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetCommandEvent* aEvent);
nsresult
NS_NewDOMMessageEvent(nsIDOMEvent** aInstancePtrResult,
mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetEvent* aEvent);
// This empties aInvalidateRequests.
nsresult
NS_NewDOMNotifyPaintEvent(nsIDOMEvent** aResult,
mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetEvent* aEvent,
uint32_t aEventType = 0,
nsInvalidateRequestList* aInvalidateRequests = nullptr);
nsresult
NS_NewDOMSimpleGestureEvent(nsIDOMEvent** aInstancePtrResult,
mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetSimpleGestureEvent* aEvent);
nsresult
NS_NewDOMScrollAreaEvent(nsIDOMEvent** aInstancePtrResult,
mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::InternalScrollAreaEvent* aEvent);
nsresult
NS_NewDOMTransitionEvent(nsIDOMEvent** aInstancePtrResult,
mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::InternalTransitionEvent* aEvent);
nsresult
NS_NewDOMAnimationEvent(nsIDOMEvent** aInstancePtrResult,
mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::InternalAnimationEvent* aEvent);
nsresult
NS_NewDOMPointerEvent(nsIDOMEvent** aInstancePtrResult,
mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetPointerEvent* aEvent);
nsresult
NS_NewDOMTouchEvent(nsIDOMEvent** aInstancePtrResult,
mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetTouchEvent* aEvent);
nsresult
NS_NewDOMCustomEvent(nsIDOMEvent** aInstancePtrResult,
mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetEvent* aEvent);
%}

9
dom/ipc/TabMessageUtils.cpp
View File

@@ -5,9 +5,9 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "mozilla/EventDispatcher.h" #include "mozilla/EventDispatcher.h"
#include "mozilla/dom/Event.h"
#include "mozilla/dom/TabMessageUtils.h" #include "mozilla/dom/TabMessageUtils.h"
#include "nsCOMPtr.h" #include "nsCOMPtr.h"
#include "nsIDOMEvent.h"
namespace mozilla { namespace mozilla {
namespace dom { namespace dom {
@@ -20,11 +20,8 @@ ReadRemoteEvent(const IPC::Message* aMsg, void** aIter,
nsString type; nsString type;
NS_ENSURE_TRUE(ReadParam(aMsg, aIter, &type), false); NS_ENSURE_TRUE(ReadParam(aMsg, aIter, &type), false);
nsCOMPtr<nsIDOMEvent> event; aResult->mEvent = EventDispatcher::CreateEvent(nullptr, nullptr, nullptr,
EventDispatcher::CreateEvent(nullptr, nullptr, nullptr, type, type);
getter_AddRefs(event));
aResult->mEvent = do_QueryInterface(event);
NS_ENSURE_TRUE(aResult->mEvent, false);
return aResult->mEvent->Deserialize(aMsg, aIter); return aResult->mEvent->Deserialize(aMsg, aIter);
} }

6
dom/ipc/TabParent.cpp
View File

@@ -3022,8 +3022,7 @@ TabParent::LayerTreeUpdate(bool aActive)
return true; return true;
} }
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<Event> event = NS_NewDOMEvent(mFrameElement, nullptr, nullptr);
NS_NewDOMEvent(getter_AddRefs(event), mFrameElement, nullptr, nullptr);
if (aActive) { if (aActive) {
event->InitEvent(NS_LITERAL_STRING("MozLayerTreeReady"), true, false); event->InitEvent(NS_LITERAL_STRING("MozLayerTreeReady"), true, false);
} else { } else {
@@ -3062,8 +3061,7 @@ TabParent::RecvRemotePaintIsReady()
return true; return true;
} }
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<Event> event = NS_NewDOMEvent(mFrameElement, nullptr, nullptr);
NS_NewDOMEvent(getter_AddRefs(event), mFrameElement, nullptr, nullptr);
event->InitEvent(NS_LITERAL_STRING("MozAfterRemotePaint"), false, false); event->InitEvent(NS_LITERAL_STRING("MozAfterRemotePaint"), false, false);
event->SetTrusted(true); event->SetTrusted(true);
event->GetInternalNSEvent()->mFlags.mOnlyChromeDispatch = true; event->GetInternalNSEvent()->mFlags.mOnlyChromeDispatch = true;

7
dom/media/MediaRecorder.cpp
View File

@@ -1030,12 +1030,7 @@ MediaRecorder::DispatchSimpleEvent(const nsAString & aStr)
return; return;
} }
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
rv = NS_NewDOMEvent(getter_AddRefs(event), this, nullptr, nullptr);
if (NS_FAILED(rv)) {
NS_WARNING("Failed to create the error event!!!");
return;
}
rv = event->InitEvent(aStr, false, false); rv = event->InitEvent(aStr, false, false);
if (NS_FAILED(rv)) { if (NS_FAILED(rv)) {

9
dom/media/TextTrackList.cpp
View File

@@ -160,14 +160,9 @@ TextTrackList::DispatchTrackEvent(nsIDOMEvent* aEvent)
void void
TextTrackList::CreateAndDispatchChangeEvent() TextTrackList::CreateAndDispatchChangeEvent()
{ {
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
nsresult rv = NS_NewDOMEvent(getter_AddRefs(event), this, nullptr, nullptr);
if (NS_FAILED(rv)) {
NS_WARNING("Failed to create the error event!");
return;
}
rv = event->InitEvent(NS_LITERAL_STRING("change"), false, false); nsresult rv = event->InitEvent(NS_LITERAL_STRING("change"), false, false);
if (NS_FAILED(rv)) { if (NS_FAILED(rv)) {
NS_WARNING("Failed to init the change event!"); NS_WARNING("Failed to init the change event!");
return; return;

16
dom/notification/DesktopNotification.cpp
View File

@@ -173,16 +173,14 @@ DesktopNotification::DispatchNotificationEvent(const nsString& aName)
return; return;
} }
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
nsresult rv = NS_NewDOMEvent(getter_AddRefs(event), this, nullptr, nullptr); // it doesn't bubble, and it isn't cancelable
if (NS_SUCCEEDED(rv)) { nsresult rv = event->InitEvent(aName, false, false);
// it doesn't bubble, and it isn't cancelable if (NS_FAILED(rv)) {
rv = event->InitEvent(aName, false, false); return;
if (NS_SUCCEEDED(rv)) {
event->SetTrusted(true);
DispatchDOMEvent(nullptr, event, nullptr, nullptr);
}
} }
event->SetTrusted(true);
DispatchDOMEvent(nullptr, event, nullptr, nullptr);
} }
nsresult nsresult

3
dom/notification/Notification.cpp
View File

@@ -1077,8 +1077,7 @@ bool
Notification::DispatchClickEvent() Notification::DispatchClickEvent()
{ {
AssertIsOnTargetThread(); AssertIsOnTargetThread();
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
NS_NewDOMEvent(getter_AddRefs(event), this, nullptr, nullptr);
nsresult rv = event->InitEvent(NS_LITERAL_STRING("click"), false, true); nsresult rv = event->InitEvent(NS_LITERAL_STRING("click"), false, true);
NS_ENSURE_SUCCESS(rv, false); NS_ENSURE_SUCCESS(rv, false);
event->SetTrusted(true); event->SetTrusted(true);

7
dom/offline/nsDOMOfflineResourceList.cpp
View File

@@ -21,6 +21,7 @@
#include "nsIObserverService.h" #include "nsIObserverService.h"
#include "nsIScriptGlobalObject.h" #include "nsIScriptGlobalObject.h"
#include "nsIWebNavigation.h" #include "nsIWebNavigation.h"
#include "mozilla/dom/Event.h"
#include "mozilla/dom/OfflineResourceListBinding.h" #include "mozilla/dom/OfflineResourceListBinding.h"
#include "mozilla/EventDispatcher.h" #include "mozilla/EventDispatcher.h"
#include "mozilla/Preferences.h" #include "mozilla/Preferences.h"
@@ -547,11 +548,7 @@ nsDOMOfflineResourceList::SendEvent(const nsAString &aEventName)
return NS_OK; return NS_OK;
} }
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
nsresult rv = EventDispatcher::CreateEvent(this, nullptr, nullptr,
NS_LITERAL_STRING("Events"),
getter_AddRefs(event));
NS_ENSURE_SUCCESS(rv, rv);
event->InitEvent(aEventName, false, true); event->InitEvent(aEventName, false, true);
// We assume anyone that managed to call SendEvent is trusted // We assume anyone that managed to call SendEvent is trusted

14
dom/presentation/PresentationSession.cpp
View File

@@ -5,8 +5,8 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "mozilla/AsyncEventDispatcher.h" #include "mozilla/AsyncEventDispatcher.h"
#include "mozilla/dom/MessageEvent.h"
#include "nsCycleCollectionParticipant.h" #include "nsCycleCollectionParticipant.h"
#include "nsIDOMMessageEvent.h"
#include "nsIPresentationService.h" #include "nsIPresentationService.h"
#include "nsServiceManagerUtils.h" #include "nsServiceManagerUtils.h"
#include "nsStringStream.h" #include "nsStringStream.h"
@@ -260,13 +260,9 @@ PresentationSession::DispatchMessageEvent(JS::Handle<JS::Value> aData)
return rv; return rv;
} }
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<MessageEvent> messageEvent =
rv = NS_NewDOMMessageEvent(getter_AddRefs(event), this, nullptr, nullptr); NS_NewDOMMessageEvent(this, nullptr, nullptr);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
nsCOMPtr<nsIDOMMessageEvent> messageEvent = do_QueryInterface(event);
rv = messageEvent->InitMessageEvent(NS_LITERAL_STRING("message"), rv = messageEvent->InitMessageEvent(NS_LITERAL_STRING("message"),
false, false, false, false,
aData, aData,
@@ -276,9 +272,9 @@ PresentationSession::DispatchMessageEvent(JS::Handle<JS::Value> aData)
return rv; return rv;
} }
event->SetTrusted(true); messageEvent->SetTrusted(true);
nsRefPtr<AsyncEventDispatcher> asyncDispatcher = nsRefPtr<AsyncEventDispatcher> asyncDispatcher =
new AsyncEventDispatcher(this, event); new AsyncEventDispatcher(this, static_cast<Event*>(messageEvent));
return asyncDispatcher->PostDOMEvent(); return asyncDispatcher->PostDOMEvent();
} }

11
dom/smil/TimeEvent.cpp
View File

@@ -80,14 +80,11 @@ TimeEvent::InitTimeEvent(const nsAString& aTypeArg,
using namespace mozilla; using namespace mozilla;
using namespace mozilla::dom; using namespace mozilla::dom;
nsresult already_AddRefed<TimeEvent>
NS_NewDOMTimeEvent(nsIDOMEvent** aInstancePtrResult, NS_NewDOMTimeEvent(EventTarget* aOwner,
EventTarget* aOwner,
nsPresContext* aPresContext, nsPresContext* aPresContext,
InternalSMILTimeEvent* aEvent) InternalSMILTimeEvent* aEvent)
{ {
TimeEvent* it = new TimeEvent(aOwner, aPresContext, aEvent); nsRefPtr<TimeEvent> it = new TimeEvent(aOwner, aPresContext, aEvent);
NS_ADDREF(it); return it.forget();
*aInstancePtrResult = static_cast<Event*>(it);
return NS_OK;
} }

5
dom/smil/TimeEvent.h
View File

@@ -63,4 +63,9 @@ private:
} // namespace dom } // namespace dom
} // namespace mozilla } // namespace mozilla
already_AddRefed<mozilla::dom::TimeEvent>
NS_NewDOMTimeEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::InternalSMILTimeEvent* aEvent);
#endif // mozilla_dom_TimeEvent_h_ #endif // mozilla_dom_TimeEvent_h_

26
dom/speakermanager/SpeakerManager.cpp
View File

@@ -5,16 +5,19 @@
* You can obtain one at http://mozilla.org/MPL/2.0/. */ * You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "SpeakerManager.h" #include "SpeakerManager.h"
#include "nsIDOMClassInfo.h"
#include "nsIDOMEvent.h"
#include "nsIDOMEventListener.h"
#include "SpeakerManagerService.h"
#include "nsIPermissionManager.h"
#include "nsIInterfaceRequestorUtils.h"
#include "nsIDocShell.h"
#include "AudioChannelService.h"
#include "mozilla/Services.h" #include "mozilla/Services.h"
#include "mozilla/dom/Event.h"
#include "AudioChannelService.h"
#include "nsIDocShell.h"
#include "nsIDOMClassInfo.h"
#include "nsIDOMEventListener.h"
#include "nsIInterfaceRequestorUtils.h"
#include "nsIPermissionManager.h"
#include "SpeakerManagerService.h"
namespace mozilla { namespace mozilla {
namespace dom { namespace dom {
@@ -86,12 +89,7 @@ SpeakerManager::DispatchSimpleEvent(const nsAString& aStr)
return; return;
} }
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
rv = NS_NewDOMEvent(getter_AddRefs(event), this, nullptr, nullptr);
if (NS_FAILED(rv)) {
NS_WARNING("Failed to create the error event!!!");
return;
}
rv = event->InitEvent(aStr, false, false); rv = event->InitEvent(aStr, false, false);
if (NS_FAILED(rv)) { if (NS_FAILED(rv)) {

13
dom/svg/SVGZoomEvent.cpp
View File

@@ -90,13 +90,14 @@ SVGZoomEvent::~SVGZoomEvent()
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
// Exported creation functions: // Exported creation functions:
nsresult using namespace mozilla;
NS_NewDOMSVGZoomEvent(nsIDOMEvent** aInstancePtrResult, using namespace mozilla::dom;
mozilla::dom::EventTarget* aOwner,
already_AddRefed<SVGZoomEvent>
NS_NewDOMSVGZoomEvent(EventTarget* aOwner,
nsPresContext* aPresContext, nsPresContext* aPresContext,
mozilla::InternalSVGZoomEvent* aEvent) mozilla::InternalSVGZoomEvent* aEvent)
{ {
mozilla::dom::SVGZoomEvent* it = nsRefPtr<SVGZoomEvent> it = new SVGZoomEvent(aOwner, aPresContext, aEvent);
new mozilla::dom::SVGZoomEvent(aOwner, aPresContext, aEvent); return it.forget();
return CallQueryInterface(it, aInstancePtrResult);
} }

5
dom/svg/SVGZoomEvent.h
View File

@@ -71,4 +71,9 @@ private:
} // namespace dom } // namespace dom
} // namespace mozilla } // namespace mozilla
already_AddRefed<mozilla::dom::SVGZoomEvent>
NS_NewDOMSVGZoomEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::InternalSVGZoomEvent* aEvent);
#endif // mozilla_dom_SVGZoomEvent_h #endif // mozilla_dom_SVGZoomEvent_h

10
dom/workers/ServiceWorkerManager.cpp
View File

@@ -2374,14 +2374,10 @@ public:
WorkerGlobalScope* globalScope = aWorkerPrivate->GlobalScope(); WorkerGlobalScope* globalScope = aWorkerPrivate->GlobalScope();
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<Event> event = NS_NewDOMEvent(globalScope, nullptr, nullptr);
nsresult rv =
NS_NewDOMEvent(getter_AddRefs(event), globalScope, nullptr, nullptr);
if (NS_WARN_IF(NS_FAILED(rv))) {
return false;
}
rv = event->InitEvent(NS_LITERAL_STRING("pushsubscriptionchange"), false, false); nsresult rv = event->InitEvent(NS_LITERAL_STRING("pushsubscriptionchange"),
false, false);
if (NS_WARN_IF(NS_FAILED(rv))) { if (NS_WARN_IF(NS_FAILED(rv))) {
return false; return false;
} }

17
dom/workers/WorkerPrivate.cpp
View File

@@ -1048,15 +1048,9 @@ private:
WorkerGlobalScope* globalScope = aWorkerPrivate->GlobalScope(); WorkerGlobalScope* globalScope = aWorkerPrivate->GlobalScope();
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<Event> event = NS_NewDOMEvent(globalScope, nullptr, nullptr);
nsresult rv =
NS_NewDOMEvent(getter_AddRefs(event), globalScope, nullptr, nullptr);
if (NS_FAILED(rv)) {
Throw(aCx, rv);
return false;
}
rv = event->InitEvent(NS_LITERAL_STRING("close"), false, false); nsresult rv = event->InitEvent(NS_LITERAL_STRING("close"), false, false);
if (NS_FAILED(rv)) { if (NS_FAILED(rv)) {
Throw(aCx, rv); Throw(aCx, rv);
return false; return false;
@@ -3619,12 +3613,9 @@ WorkerPrivate::OfflineStatusChangeEventInternal(JSContext* aCx, bool aIsOffline)
eventType.AssignLiteral("online"); eventType.AssignLiteral("online");
} }
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<Event> event = NS_NewDOMEvent(globalScope, nullptr, nullptr);
nsresult rv =
NS_NewDOMEvent(getter_AddRefs(event), globalScope, nullptr, nullptr);
NS_ENSURE_SUCCESS_VOID(rv);
rv = event->InitEvent(eventType, false, false); nsresult rv = event->InitEvent(eventType, false, false);
NS_ENSURE_SUCCESS_VOID(rv); NS_ENSURE_SUCCESS_VOID(rv);
event->SetTrusted(true); event->SetTrusted(true);

13
dom/workers/XMLHttpRequest.cpp
View File

@@ -1395,7 +1395,7 @@ EventRunnable::WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate)
MOZ_ASSERT(target); MOZ_ASSERT(target);
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<Event> event;
if (mProgressEvent) { if (mProgressEvent) {
ProgressEventInit init; ProgressEventInit init;
init.mBubbles = false; init.mBubbles = false;
@@ -1407,7 +1407,7 @@ EventRunnable::WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate)
event = ProgressEvent::Constructor(target, mType, init); event = ProgressEvent::Constructor(target, mType, init);
} }
else { else {
NS_NewDOMEvent(getter_AddRefs(event), target, nullptr, nullptr); event = NS_NewDOMEvent(target, nullptr, nullptr);
if (event) { if (event) {
event->InitEvent(mType, false, false); event->InitEvent(mType, false, false);
@@ -1796,13 +1796,10 @@ XMLHttpRequest::DispatchPrematureAbortEvent(EventTarget* aTarget,
return; return;
} }
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<Event> event;
if (aEventType.EqualsLiteral("readystatechange")) { if (aEventType.EqualsLiteral("readystatechange")) {
NS_NewDOMEvent(getter_AddRefs(event), aTarget, nullptr, nullptr); event = NS_NewDOMEvent(aTarget, nullptr, nullptr);
event->InitEvent(aEventType, false, false);
if (event) {
event->InitEvent(aEventType, false, false);
}
} }
else { else {
ProgressEventInit init; ProgressEventInit init;

21
dom/xml/nsXMLPrettyPrinter.cpp
View File

@@ -23,7 +23,7 @@
#include "mozilla/Preferences.h" #include "mozilla/Preferences.h"
#include "nsIDocument.h" #include "nsIDocument.h"
#include "nsVariant.h" #include "nsVariant.h"
#include "nsIDOMCustomEvent.h" #include "mozilla/dom/CustomEvent.h"
using namespace mozilla; using namespace mozilla;
using namespace mozilla::dom; using namespace mozilla::dom;
@@ -156,22 +156,19 @@ nsXMLPrettyPrinter::PrettyPrint(nsIDocument* aDocument,
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
// Fire an event at the bound element to pass it |resultFragment|. // Fire an event at the bound element to pass it |resultFragment|.
nsCOMPtr<nsIDOMEvent> domEvent; nsRefPtr<CustomEvent> event =
rv = NS_NewDOMCustomEvent(getter_AddRefs(domEvent), rootCont, NS_NewDOMCustomEvent(rootCont, nullptr, nullptr);
nullptr, nullptr); MOZ_ASSERT(event);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIDOMCustomEvent> customEvent = do_QueryInterface(domEvent);
MOZ_ASSERT(customEvent);
nsCOMPtr<nsIWritableVariant> resultFragmentVariant = new nsVariant(); nsCOMPtr<nsIWritableVariant> resultFragmentVariant = new nsVariant();
rv = resultFragmentVariant->SetAsISupports(resultFragment); rv = resultFragmentVariant->SetAsISupports(resultFragment);
MOZ_ASSERT(NS_SUCCEEDED(rv)); MOZ_ASSERT(NS_SUCCEEDED(rv));
rv = customEvent->InitCustomEvent(NS_LITERAL_STRING("prettyprint-dom-created"), rv = event->InitCustomEvent(NS_LITERAL_STRING("prettyprint-dom-created"),
/* bubbles = */ false, /* cancelable = */ false, /* bubbles = */ false, /* cancelable = */ false,
/* detail = */ resultFragmentVariant); /* detail = */ resultFragmentVariant);
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
customEvent->SetTrusted(true); event->SetTrusted(true);
bool dummy; bool dummy;
rv = rootCont->DispatchEvent(domEvent, &dummy); rv = rootCont->DispatchEvent(static_cast<Event*>(event), &dummy);
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
// Observe the document so we know when to switch to "normal" view // Observe the document so we know when to switch to "normal" view

16
layout/base/nsPresContext.cpp
View File

@@ -57,7 +57,7 @@
#include "nsRefreshDriver.h" #include "nsRefreshDriver.h"
#include "Layers.h" #include "Layers.h"
#include "ClientLayerManager.h" #include "ClientLayerManager.h"
#include "nsIDOMEvent.h" #include "mozilla/dom/NotifyPaintEvent.h"
#include "gfxPrefs.h" #include "gfxPrefs.h"
#include "nsIDOMChromeWindow.h" #include "nsIDOMChromeWindow.h"
#include "nsFrameLoader.h" #include "nsFrameLoader.h"
@@ -2255,23 +2255,21 @@ nsPresContext::FireDOMPaintEvent(nsInvalidateRequestList* aList)
} }
// Events sent to the window get propagated to the chrome event handler // Events sent to the window get propagated to the chrome event handler
// automatically. // automatically.
nsCOMPtr<nsIDOMEvent> event; //
// This will empty our list in case dispatching the event causes more damage // This will empty our list in case dispatching the event causes more damage
// (hopefully it won't, or we're likely to get an infinite loop! At least // (hopefully it won't, or we're likely to get an infinite loop! At least
// it won't be blocking app execution though). // it won't be blocking app execution though).
NS_NewDOMNotifyPaintEvent(getter_AddRefs(event), eventTarget, this, nullptr, nsRefPtr<NotifyPaintEvent> event =
NS_AFTERPAINT, aList); NS_NewDOMNotifyPaintEvent(eventTarget, this, nullptr, NS_AFTERPAINT,
if (!event) { aList);
return;
}
// Even if we're not telling the window about the event (so eventTarget is // Even if we're not telling the window about the event (so eventTarget is
// the chrome event handler, not the window), the window is still // the chrome event handler, not the window), the window is still
// logically the event target. // logically the event target.
event->SetTarget(eventTarget); event->SetTarget(eventTarget);
event->SetTrusted(true); event->SetTrusted(true);
EventDispatcher::DispatchDOMEvent(dispatchTarget, nullptr, event, this, EventDispatcher::DispatchDOMEvent(dispatchTarget, nullptr,
nullptr); static_cast<Event*>(event), this, nullptr);
} }
static bool static bool

15
layout/xul/nsMenuFrame.cpp
View File

@@ -44,6 +44,7 @@
#include "mozilla/Services.h" #include "mozilla/Services.h"
#include "mozilla/TextEvents.h" #include "mozilla/TextEvents.h"
#include "mozilla/dom/Element.h" #include "mozilla/dom/Element.h"
#include "mozilla/dom/Event.h"
#include <algorithm> #include <algorithm>
using namespace mozilla; using namespace mozilla;
@@ -94,17 +95,13 @@ public:
domEventToFire.AssignLiteral("DOMMenuItemInactive"); domEventToFire.AssignLiteral("DOMMenuItemInactive");
} }
nsCOMPtr<nsIDOMEvent> event; nsRefPtr<Event> event = NS_NewDOMEvent(mMenu, mPresContext, nullptr);
if (NS_SUCCEEDED(EventDispatcher::CreateEvent(mMenu, mPresContext, nullptr, event->InitEvent(domEventToFire, true, true);
NS_LITERAL_STRING("Events"),
getter_AddRefs(event)))) {
event->InitEvent(domEventToFire, true, true);
event->SetTrusted(true); event->SetTrusted(true);
EventDispatcher::DispatchDOMEvent(mMenu, nullptr, event, EventDispatcher::DispatchDOMEvent(mMenu, nullptr, event,
mPresContext, nullptr); mPresContext, nullptr);
}
return NS_OK; return NS_OK;
} }