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

42
dom/base/EventSource.cpp
View File

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

22
dom/base/WebSocket.cpp
View File

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

19
dom/base/nsDOMDataChannel.cpp
View File

@@ -17,9 +17,9 @@ extern PRLogModuleInfo* GetDataChannelLog();
#include "nsDOMDataChannelDeclarations.h"
#include "nsDOMDataChannel.h"
#include "nsIDOMDataChannel.h"
#include "nsIDOMMessageEvent.h"
#include "mozilla/DOMEventTargetHelper.h"
#include "mozilla/dom/File.h"
#include "mozilla/dom/MessageEvent.h"
#include "mozilla/dom/ScriptSettings.h"
#include "nsError.h"
@@ -401,20 +401,15 @@ nsDOMDataChannel::DoOnMessageAvailable(const nsACString& aData,
jsData.setString(jsString);
}
nsCOMPtr<nsIDOMEvent> event;
rv = NS_NewDOMMessageEvent(getter_AddRefs(event), this, nullptr, nullptr);
NS_ENSURE_SUCCESS(rv,rv);
nsRefPtr<MessageEvent> event = NS_NewDOMMessageEvent(this, nullptr, nullptr);
nsCOMPtr<nsIDOMMessageEvent> messageEvent = do_QueryInterface(event);
rv = messageEvent->InitMessageEvent(NS_LITERAL_STRING("message"),
false, false,
jsData, mOrigin, EmptyString(),
nullptr);
rv = event->InitMessageEvent(NS_LITERAL_STRING("message"), false, false,
jsData, mOrigin, EmptyString(), nullptr);
NS_ENSURE_SUCCESS(rv,rv);
event->SetTrusted(true);
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)) {
NS_WARNING("Failed to dispatch the message event!!!");
}
@@ -447,9 +442,7 @@ nsDOMDataChannel::OnSimpleEvent(nsISupports* aContext, const nsAString& aName)
return NS_OK;
}
nsCOMPtr<nsIDOMEvent> event;
rv = NS_NewDOMEvent(getter_AddRefs(event), this, nullptr, nullptr);
NS_ENSURE_SUCCESS(rv,rv);
nsRefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
rv = event->InitEvent(aName, false, false);
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.
nsCOMPtr<nsIDOMEvent> ev;
rv = EventDispatcher::CreateEvent(const_cast<nsIDocument*>(this),
presContext, nullptr, aEventType,
getter_AddRefs(ev));
nsRefPtr<Event> ev =
EventDispatcher::CreateEvent(const_cast<nsIDocument*>(this), presContext,
nullptr, aEventType);
if (!ev) {
rv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
return nullptr;
}
WidgetEvent* e = ev->GetInternalNSEvent();
e->mFlags.mBubbles = false;
e->mFlags.mCancelable = false;
return dont_AddRef(ev.forget().take()->InternalDOMEvent());
return ev.forget();
}
void
@@ -9209,8 +9209,7 @@ static void
DispatchCustomEventWithFlush(nsINode* aTarget, const nsAString& aEventType,
bool aBubbles, bool aOnlyChromeDispatch)
{
nsCOMPtr<nsIDOMEvent> event;
NS_NewDOMEvent(getter_AddRefs(event), aTarget, nullptr, nullptr);
nsRefPtr<Event> event = NS_NewDOMEvent(aTarget, nullptr, nullptr);
nsresult rv = event->InitEvent(aEventType, aBubbles, false);
if (NS_FAILED(rv)) {
return;

9
dom/base/nsGlobalWindow.cpp
View File

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

13
dom/base/nsPerformance.cpp
View File

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

8
dom/base/nsXMLHttpRequest.cpp
View File

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

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

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

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

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

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

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

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

@@ -102,16 +102,10 @@ DispatchCustomDOMEvent(Element* aFrameElement, const nsAString& aEventName,
presContext = shell->GetPresContext();
}
nsCOMPtr<nsIDOMEvent> domEvent;
EventDispatcher::CreateEvent(aFrameElement, presContext, nullptr,
NS_LITERAL_STRING("customevent"),
getter_AddRefs(domEvent));
NS_ENSURE_TRUE(domEvent, false);
nsRefPtr<CustomEvent> event =
NS_NewDOMCustomEvent(aFrameElement, presContext, nullptr);
nsCOMPtr<nsIDOMCustomEvent> customEvent = do_QueryInterface(domEvent);
NS_ENSURE_TRUE(customEvent, false);
ErrorResult res;
CustomEvent* event = static_cast<CustomEvent*>(customEvent.get());
event->InitCustomEvent(cx,
aEventName,
/* bubbles = */ true,
@@ -121,12 +115,13 @@ DispatchCustomDOMEvent(Element* aFrameElement, const nsAString& aEventName,
if (res.Failed()) {
return false;
}
customEvent->SetTrusted(true);
event->SetTrusted(true);
// Dispatch the event.
*aStatus = nsEventStatus_eConsumeNoDefault;
nsresult rv =
EventDispatcher::DispatchDOMEvent(aFrameElement, nullptr,
domEvent, presContext, aStatus);
static_cast<Event*>(event),
presContext, aStatus);
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::dom;
nsresult
NS_NewDOMAnimationEvent(nsIDOMEvent** aInstancePtrResult,
EventTarget* aOwner,
already_AddRefed<AnimationEvent>
NS_NewDOMAnimationEvent(EventTarget* aOwner,
nsPresContext* aPresContext,
InternalAnimationEvent* aEvent)
{
AnimationEvent* it = new AnimationEvent(aOwner, aPresContext, aEvent);
NS_ADDREF(it);
*aInstancePtrResult = static_cast<Event*>(it);
return NS_OK;
nsRefPtr<AnimationEvent> it =
new AnimationEvent(aOwner, aPresContext, aEvent);
return it.forget();
}

5
dom/events/AnimationEvent.h
View File

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

11
dom/events/AsyncEventDispatcher.cpp
View File

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

12
dom/events/BeforeAfterKeyboardEvent.cpp
View File

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

5
dom/events/BeforeAfterKeyboardEvent.h
View File

@@ -43,4 +43,9 @@ public:
} // namespace dom
} // namespace mozilla
already_AddRefed<mozilla::dom::BeforeAfterKeyboardEvent>
NS_NewDOMBeforeAfterKeyboardEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::InternalBeforeAfterKeyboardEvent* aEvent);
#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::dom;
nsresult
NS_NewDOMBeforeUnloadEvent(nsIDOMEvent** aInstancePtrResult,
EventTarget* aOwner,
already_AddRefed<BeforeUnloadEvent>
NS_NewDOMBeforeUnloadEvent(EventTarget* aOwner,
nsPresContext* aPresContext,
WidgetEvent* aEvent)
{
BeforeUnloadEvent* it = new BeforeUnloadEvent(aOwner, aPresContext, aEvent);
NS_ADDREF(it);
*aInstancePtrResult = static_cast<Event*>(it);
return NS_OK;
nsRefPtr<BeforeUnloadEvent> it =
new BeforeUnloadEvent(aOwner, aPresContext, aEvent);
return it.forget();
}

5
dom/events/BeforeUnloadEvent.h
View File

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

12
dom/events/ClipboardEvent.cpp
View File

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

5
dom/events/ClipboardEvent.h
View File

@@ -56,4 +56,9 @@ protected:
} // namespace dom
} // namespace mozilla
already_AddRefed<mozilla::dom::ClipboardEvent>
NS_NewDOMClipboardEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::InternalClipboardEvent* aEvent);
#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::dom;
nsresult
NS_NewDOMCommandEvent(nsIDOMEvent** aInstancePtrResult,
EventTarget* aOwner,
already_AddRefed<CommandEvent>
NS_NewDOMCommandEvent(EventTarget* aOwner,
nsPresContext* aPresContext,
WidgetCommandEvent* aEvent)
{
CommandEvent* it = new CommandEvent(aOwner, aPresContext, aEvent);
NS_ADDREF(it);
*aInstancePtrResult = static_cast<Event*>(it);
return NS_OK;
nsRefPtr<CommandEvent> it =
new CommandEvent(aOwner, aPresContext, aEvent);
return it.forget();
}

5
dom/events/CommandEvent.h
View File

@@ -51,4 +51,9 @@ protected:
} // namespace dom
} // namespace mozilla
already_AddRefed<mozilla::dom::CommandEvent>
NS_NewDOMCommandEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetCommandEvent* aEvent);
#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::dom;
nsresult
NS_NewDOMCompositionEvent(nsIDOMEvent** aInstancePtrResult,
EventTarget* aOwner,
already_AddRefed<CompositionEvent>
NS_NewDOMCompositionEvent(EventTarget* aOwner,
nsPresContext* aPresContext,
WidgetCompositionEvent* aEvent)
{
CompositionEvent* event = new CompositionEvent(aOwner, aPresContext, aEvent);
return CallQueryInterface(event, aInstancePtrResult);
nsRefPtr<CompositionEvent> event =
new CompositionEvent(aOwner, aPresContext, aEvent);
return event.forget();
}

5
dom/events/CompositionEvent.h
View File

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

12
dom/events/CustomEvent.cpp
View File

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

5
dom/events/CustomEvent.h
View File

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

3
dom/events/DOMEventTargetHelper.cpp
View File

@@ -262,8 +262,7 @@ DOMEventTargetHelper::DispatchEvent(nsIDOMEvent* aEvent, bool* aRetVal)
nsresult
DOMEventTargetHelper::DispatchTrustedEvent(const nsAString& aEventName)
{
nsCOMPtr<nsIDOMEvent> event;
NS_NewDOMEvent(getter_AddRefs(event), this, nullptr, nullptr);
nsRefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
nsresult rv = event->InitEvent(aEventName, false, false);
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::dom;
nsresult
NS_NewDOMDataContainerEvent(nsIDOMEvent** aInstancePtrResult,
EventTarget* aOwner,
already_AddRefed<DataContainerEvent>
NS_NewDOMDataContainerEvent(EventTarget* aOwner,
nsPresContext* aPresContext,
WidgetEvent* aEvent)
{
DataContainerEvent* it = new DataContainerEvent(aOwner, aPresContext, aEvent);
NS_ADDREF(it);
*aInstancePtrResult = static_cast<Event*>(it);
return NS_OK;
nsRefPtr<DataContainerEvent> it =
new DataContainerEvent(aOwner, aPresContext, aEvent);
return it.forget();
}

5
dom/events/DataContainerEvent.h
View File

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

14
dom/events/DeviceMotionEvent.cpp
View File

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

5
dom/events/DeviceMotionEvent.h
View File

@@ -149,4 +149,9 @@ protected:
} // namespace dom
} // namespace mozilla
already_AddRefed<mozilla::dom::DeviceMotionEvent>
NS_NewDOMDeviceMotionEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetEvent* aEvent);
#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::dom;
nsresult
NS_NewDOMDragEvent(nsIDOMEvent** aInstancePtrResult,
EventTarget* aOwner,
already_AddRefed<DragEvent>
NS_NewDOMDragEvent(EventTarget* aOwner,
nsPresContext* aPresContext,
WidgetDragEvent* aEvent)
{
DragEvent* event = new DragEvent(aOwner, aPresContext, aEvent);
return CallQueryInterface(event, aInstancePtrResult);
nsRefPtr<DragEvent> event =
new DragEvent(aOwner, aPresContext, aEvent);
return event.forget();
}

5
dom/events/DragEvent.h
View File

@@ -61,4 +61,9 @@ protected:
} // namespace dom
} // namespace mozilla
already_AddRefed<mozilla::dom::DragEvent>
NS_NewDOMDragEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetDragEvent* aEvent);
#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::dom;
nsresult
NS_NewDOMEvent(nsIDOMEvent** aInstancePtrResult,
EventTarget* aOwner,
already_AddRefed<Event>
NS_NewDOMEvent(EventTarget* aOwner,
nsPresContext* aPresContext,
WidgetEvent* aEvent)
{
Event* it = new Event(aOwner, aPresContext, aEvent);
NS_ADDREF(it);
*aInstancePtrResult = static_cast<Event*>(it);
return NS_OK;
nsRefPtr<Event> it = new Event(aOwner, aPresContext, aEvent);
return it.forget();
}

5
dom/events/Event.h
View File

@@ -340,4 +340,9 @@ ToCanonicalSupports(mozilla::dom::Event* 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_

138
dom/events/EventDispatcher.cpp
View File

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

8
dom/events/EventDispatcher.h
View File

@@ -23,6 +23,7 @@ template<class E> class nsCOMArray;
namespace mozilla {
namespace dom {
class Event;
class EventTarget;
} // namespace dom
@@ -272,13 +273,12 @@ public:
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,
WidgetEvent* aEvent,
const nsAString& aEventType,
nsIDOMEvent** aDOMEvent);
const nsAString& aEventType);
/**
* 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.
nsCOMPtr<EventTarget> et =
do_QueryInterface(aEvent->originalTarget);
EventDispatcher::CreateEvent(et, aPresContext,
aEvent, EmptyString(), aDOMEvent);
nsRefPtr<Event> event = EventDispatcher::CreateEvent(et, aPresContext,
aEvent,
EmptyString());
event.forget(aDOMEvent);
}
if (*aDOMEvent) {
if (!aEvent->currentTarget) {

17
dom/events/EventStateManager.cpp
View File

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

11
dom/events/FocusEvent.cpp
View File

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

5
dom/events/FocusEvent.h
View File

@@ -53,4 +53,9 @@ protected:
} // namespace dom
} // namespace mozilla
already_AddRefed<mozilla::dom::FocusEvent>
NS_NewDOMFocusEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::InternalFocusEvent* aEvent);
#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::dom;
nsresult
NS_NewDOMInputEvent(nsIDOMEvent** aInstancePtrResult,
EventTarget* aOwner,
already_AddRefed<InputEvent>
NS_NewDOMInputEvent(EventTarget* aOwner,
nsPresContext* aPresContext,
InternalEditorInputEvent* aEvent)
{
InputEvent* it = new InputEvent(aOwner, aPresContext, aEvent);
NS_ADDREF(it);
*aInstancePtrResult = static_cast<Event*>(it);
return NS_OK;
nsRefPtr<InputEvent> it = new InputEvent(aOwner, aPresContext, aEvent);
return it.forget();
}

5
dom/events/InputEvent.h
View File

@@ -46,4 +46,9 @@ protected:
} // namespace dom
} // namespace mozilla
already_AddRefed<mozilla::dom::InputEvent>
NS_NewDOMInputEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::InternalEditorInputEvent* aEvent);
#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::dom;
nsresult
NS_NewDOMKeyboardEvent(nsIDOMEvent** aInstancePtrResult,
EventTarget* aOwner,
already_AddRefed<KeyboardEvent>
NS_NewDOMKeyboardEvent(EventTarget* aOwner,
nsPresContext* aPresContext,
WidgetKeyboardEvent* aEvent)
{
KeyboardEvent* it = new KeyboardEvent(aOwner, aPresContext, aEvent);
NS_ADDREF(it);
*aInstancePtrResult = static_cast<Event*>(it);
return NS_OK;
nsRefPtr<KeyboardEvent> it = new KeyboardEvent(aOwner, aPresContext, aEvent);
return it.forget();
}

5
dom/events/KeyboardEvent.h
View File

@@ -93,4 +93,9 @@ private:
} // namespace dom
} // namespace mozilla
already_AddRefed<mozilla::dom::KeyboardEvent>
NS_NewDOMKeyboardEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetKeyboardEvent* aEvent);
#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());
}
event->mPorts = new MessagePortList(static_cast<EventBase*>(event), ports);
event->mPorts = new MessagePortList(static_cast<Event*>(event), ports);
}
return event.forget();
@@ -224,14 +224,11 @@ MessageEvent::SetSource(mozilla::dom::workers::ServiceWorkerClient* aClient)
using namespace mozilla;
using namespace mozilla::dom;
nsresult
NS_NewDOMMessageEvent(nsIDOMEvent** aInstancePtrResult,
EventTarget* aOwner,
already_AddRefed<MessageEvent>
NS_NewDOMMessageEvent(EventTarget* aOwner,
nsPresContext* aPresContext,
WidgetEvent* aEvent)
{
MessageEvent* it = new MessageEvent(aOwner, aPresContext, aEvent);
NS_ADDREF(it);
*aInstancePtrResult = static_cast<Event*>(it);
return NS_OK;
nsRefPtr<MessageEvent> it = new MessageEvent(aOwner, aPresContext, aEvent);
return it.forget();
}

5
dom/events/MessageEvent.h
View File

@@ -102,4 +102,9 @@ private:
} // namespace dom
} // namespace mozilla
already_AddRefed<mozilla::dom::MessageEvent>
NS_NewDOMMessageEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetEvent* aEvent);
#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::dom;
nsresult
NS_NewDOMMouseEvent(nsIDOMEvent** aInstancePtrResult,
EventTarget* aOwner,
already_AddRefed<MouseEvent>
NS_NewDOMMouseEvent(EventTarget* aOwner,
nsPresContext* aPresContext,
WidgetMouseEvent* aEvent)
{
MouseEvent* it = new MouseEvent(aOwner, aPresContext, aEvent);
NS_ADDREF(it);
*aInstancePtrResult = static_cast<Event*>(it);
return NS_OK;
nsRefPtr<MouseEvent> it = new MouseEvent(aOwner, aPresContext, aEvent);
return it.forget();
}

5
dom/events/MouseEvent.h
View File

@@ -132,4 +132,9 @@ protected:
NS_FORWARD_NSIDOMMOUSEEVENT(MouseEvent::) \
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_

12
dom/events/MouseScrollEvent.cpp
View File

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

5
dom/events/MouseScrollEvent.h
View File

@@ -59,4 +59,9 @@ protected:
} // namespace dom
} // namespace mozilla
already_AddRefed<mozilla::dom::MouseScrollEvent>
NS_NewDOMMouseScrollEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetMouseScrollEvent* aEvent);
#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::dom;
nsresult
NS_NewDOMMutationEvent(nsIDOMEvent** aInstancePtrResult,
EventTarget* aOwner,
already_AddRefed<MutationEvent>
NS_NewDOMMutationEvent(EventTarget* aOwner,
nsPresContext* aPresContext,
InternalMutationEvent* aEvent)
{
MutationEvent* it = new MutationEvent(aOwner, aPresContext, aEvent);
NS_ADDREF(it);
*aInstancePtrResult = static_cast<Event*>(it);
return NS_OK;
nsRefPtr<MutationEvent> it = new MutationEvent(aOwner, aPresContext, aEvent);
return it.forget();
}

5
dom/events/MutationEvent.h
View File

@@ -65,4 +65,9 @@ protected:
} // namespace dom
} // namespace mozilla
already_AddRefed<mozilla::dom::MutationEvent>
NS_NewDOMMutationEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::InternalMutationEvent* aEvent);
#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::dom;
nsresult
NS_NewDOMNotifyPaintEvent(nsIDOMEvent** aInstancePtrResult,
EventTarget* aOwner,
already_AddRefed<NotifyPaintEvent>
NS_NewDOMNotifyPaintEvent(EventTarget* aOwner,
nsPresContext* aPresContext,
WidgetEvent* aEvent,
uint32_t aEventType,
nsInvalidateRequestList* aInvalidateRequests)
{
NotifyPaintEvent* it = new NotifyPaintEvent(aOwner, aPresContext, aEvent,
aEventType, aInvalidateRequests);
NS_ADDREF(it);
*aInstancePtrResult = static_cast<Event*>(it);
return NS_OK;
nsRefPtr<NotifyPaintEvent> it =
new NotifyPaintEvent(aOwner, aPresContext, aEvent, aEventType,
aInvalidateRequests);
return it.forget();
}

8
dom/events/NotifyPaintEvent.h
View File

@@ -67,4 +67,12 @@ private:
} // namespace dom
} // 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_

11
dom/events/PointerEvent.cpp
View File

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

5
dom/events/PointerEvent.h
View File

@@ -55,4 +55,9 @@ void ConvertPointerTypeToString(uint16_t aPointerTypeSrc, nsAString& aPointerTyp
} // namespace dom
} // namespace mozilla
already_AddRefed<mozilla::dom::PointerEvent>
NS_NewDOMPointerEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetPointerEvent* aEvent);
#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::dom;
nsresult
NS_NewDOMScrollAreaEvent(nsIDOMEvent** aInstancePtrResult,
EventTarget* aOwner,
already_AddRefed<ScrollAreaEvent>
NS_NewDOMScrollAreaEvent(EventTarget* aOwner,
nsPresContext* aPresContext,
InternalScrollAreaEvent* aEvent)
{
ScrollAreaEvent* ev = new ScrollAreaEvent(aOwner, aPresContext, aEvent);
return CallQueryInterface(ev, aInstancePtrResult);
nsRefPtr<ScrollAreaEvent> ev =
new ScrollAreaEvent(aOwner, aPresContext, aEvent);
return ev.forget();
}

5
dom/events/ScrollAreaEvent.h
View File

@@ -86,4 +86,9 @@ protected:
} // namespace dom
} // namespace mozilla
already_AddRefed<mozilla::dom::ScrollAreaEvent>
NS_NewDOMScrollAreaEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::InternalScrollAreaEvent* aEvent);
#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::dom;
nsresult
NS_NewDOMSimpleGestureEvent(nsIDOMEvent** aInstancePtrResult,
EventTarget* aOwner,
already_AddRefed<SimpleGestureEvent>
NS_NewDOMSimpleGestureEvent(EventTarget* aOwner,
nsPresContext* aPresContext,
WidgetSimpleGestureEvent* aEvent)
{
SimpleGestureEvent* it = new SimpleGestureEvent(aOwner, aPresContext, aEvent);
NS_ADDREF(it);
*aInstancePtrResult = static_cast<Event*>(it);
return NS_OK;
nsRefPtr<SimpleGestureEvent> it =
new SimpleGestureEvent(aOwner, aPresContext, aEvent);
return it.forget();
}

5
dom/events/SimpleGestureEvent.h
View File

@@ -78,4 +78,9 @@ protected:
} // namespace dom
} // namespace mozilla
already_AddRefed<mozilla::dom::SimpleGestureEvent>
NS_NewDOMSimpleGestureEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetSimpleGestureEvent* aEvent);
#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 mozilla
nsresult
NS_NewDOMStorageEvent(nsIDOMEvent** aDOMEvent,
mozilla::dom::EventTarget* aOwner)
using namespace mozilla;
using namespace mozilla::dom;
already_AddRefed<StorageEvent>
NS_NewDOMStorageEvent(EventTarget* aOwner)
{
nsRefPtr<mozilla::dom::StorageEvent> e =
new mozilla::dom::StorageEvent(aOwner);
nsRefPtr<StorageEvent> e = new StorageEvent(aOwner);
e->SetTrusted(e->Init(aOwner));
e.forget(aDOMEvent);
return NS_OK;
return e.forget();
}

4
dom/events/StorageEvent.h
View File

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

11
dom/events/TouchEvent.cpp
View File

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

5
dom/events/TouchEvent.h
View File

@@ -132,4 +132,9 @@ protected:
} // namespace dom
} // namespace mozilla
already_AddRefed<mozilla::dom::TouchEvent>
NS_NewDOMTouchEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetTouchEvent* aEvent);
#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::dom;
nsresult
NS_NewDOMTransitionEvent(nsIDOMEvent** aInstancePtrResult,
EventTarget* aOwner,
already_AddRefed<TransitionEvent>
NS_NewDOMTransitionEvent(EventTarget* aOwner,
nsPresContext* aPresContext,
InternalTransitionEvent* aEvent)
{
TransitionEvent *it = new TransitionEvent(aOwner, aPresContext, aEvent);
NS_ADDREF(it);
*aInstancePtrResult = static_cast<Event*>(it);
return NS_OK;
nsRefPtr<TransitionEvent> it =
new TransitionEvent(aOwner, aPresContext, aEvent);
return it.forget();
}

5
dom/events/TransitionEvent.h
View File

@@ -52,4 +52,9 @@ protected:
} // namespace dom
} // namespace mozilla
already_AddRefed<mozilla::dom::TransitionEvent>
NS_NewDOMTransitionEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::InternalTransitionEvent* aEvent);
#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::dom;
nsresult
NS_NewDOMUIEvent(nsIDOMEvent** aInstancePtrResult,
EventTarget* aOwner,
already_AddRefed<UIEvent>
NS_NewDOMUIEvent(EventTarget* aOwner,
nsPresContext* aPresContext,
WidgetGUIEvent* aEvent)
{
UIEvent* it = new UIEvent(aOwner, aPresContext, aEvent);
NS_ADDREF(it);
*aInstancePtrResult = static_cast<Event*>(it);
return NS_OK;
nsRefPtr<UIEvent> it = new UIEvent(aOwner, aPresContext, aEvent);
return it.forget();
}

5
dom/events/UIEvent.h
View File

@@ -194,4 +194,9 @@ protected:
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_

11
dom/events/WheelEvent.cpp
View File

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

5
dom/events/WheelEvent.h
View File

@@ -60,4 +60,9 @@ private:
} // namespace dom
} // namespace mozilla
already_AddRefed<mozilla::dom::WheelEvent>
NS_NewDOMWheelEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::WidgetWheelEvent* aEvent);
#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::dom;
nsresult
NS_NewDOMXULCommandEvent(nsIDOMEvent** aInstancePtrResult,
EventTarget* aOwner,
already_AddRefed<XULCommandEvent>
NS_NewDOMXULCommandEvent(EventTarget* aOwner,
nsPresContext* aPresContext,
WidgetInputEvent* aEvent)
{
XULCommandEvent* it = new XULCommandEvent(aOwner, aPresContext, aEvent);
NS_ADDREF(it);
*aInstancePtrResult = static_cast<Event*>(it);
return NS_OK;
nsRefPtr<XULCommandEvent> it =
new XULCommandEvent(aOwner, aPresContext, aEvent);
return it.forget();
}

5
dom/events/XULCommandEvent.h
View File

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

1
dom/events/moz.build
View File

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

6
dom/html/HTMLInputElement.cpp
View File

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

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

@@ -215,162 +215,3 @@ interface nsIDOMEvent : nsISupports
[notxpcom] DOMEventPtr InternalDOMEvent();
[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/. */
#include "mozilla/EventDispatcher.h"
#include "mozilla/dom/Event.h"
#include "mozilla/dom/TabMessageUtils.h"
#include "nsCOMPtr.h"
#include "nsIDOMEvent.h"
namespace mozilla {
namespace dom {
@@ -20,11 +20,8 @@ ReadRemoteEvent(const IPC::Message* aMsg, void** aIter,
nsString type;
NS_ENSURE_TRUE(ReadParam(aMsg, aIter, &type), false);
nsCOMPtr<nsIDOMEvent> event;
EventDispatcher::CreateEvent(nullptr, nullptr, nullptr, type,
getter_AddRefs(event));
aResult->mEvent = do_QueryInterface(event);
NS_ENSURE_TRUE(aResult->mEvent, false);
aResult->mEvent = EventDispatcher::CreateEvent(nullptr, nullptr, nullptr,
type);
return aResult->mEvent->Deserialize(aMsg, aIter);
}

6
dom/ipc/TabParent.cpp
View File

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

7
dom/media/MediaRecorder.cpp
View File

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

9
dom/media/TextTrackList.cpp
View File

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

12
dom/notification/DesktopNotification.cpp
View File

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

3
dom/notification/Notification.cpp
View File

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

7
dom/offline/nsDOMOfflineResourceList.cpp
View File

@@ -21,6 +21,7 @@
#include "nsIObserverService.h"
#include "nsIScriptGlobalObject.h"
#include "nsIWebNavigation.h"
#include "mozilla/dom/Event.h"
#include "mozilla/dom/OfflineResourceListBinding.h"
#include "mozilla/EventDispatcher.h"
#include "mozilla/Preferences.h"
@@ -547,11 +548,7 @@ nsDOMOfflineResourceList::SendEvent(const nsAString &aEventName)
return NS_OK;
}
nsCOMPtr<nsIDOMEvent> event;
nsresult rv = EventDispatcher::CreateEvent(this, nullptr, nullptr,
NS_LITERAL_STRING("Events"),
getter_AddRefs(event));
NS_ENSURE_SUCCESS(rv, rv);
nsRefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
event->InitEvent(aEventName, false, true);
// 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/. */
#include "mozilla/AsyncEventDispatcher.h"
#include "mozilla/dom/MessageEvent.h"
#include "nsCycleCollectionParticipant.h"
#include "nsIDOMMessageEvent.h"
#include "nsIPresentationService.h"
#include "nsServiceManagerUtils.h"
#include "nsStringStream.h"
@@ -260,13 +260,9 @@ PresentationSession::DispatchMessageEvent(JS::Handle<JS::Value> aData)
return rv;
}
nsCOMPtr<nsIDOMEvent> event;
rv = NS_NewDOMMessageEvent(getter_AddRefs(event), this, nullptr, nullptr);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
nsRefPtr<MessageEvent> messageEvent =
NS_NewDOMMessageEvent(this, nullptr, nullptr);
nsCOMPtr<nsIDOMMessageEvent> messageEvent = do_QueryInterface(event);
rv = messageEvent->InitMessageEvent(NS_LITERAL_STRING("message"),
false, false,
aData,
@@ -276,9 +272,9 @@ PresentationSession::DispatchMessageEvent(JS::Handle<JS::Value> aData)
return rv;
}
event->SetTrusted(true);
messageEvent->SetTrusted(true);
nsRefPtr<AsyncEventDispatcher> asyncDispatcher =
new AsyncEventDispatcher(this, event);
new AsyncEventDispatcher(this, static_cast<Event*>(messageEvent));
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::dom;
nsresult
NS_NewDOMTimeEvent(nsIDOMEvent** aInstancePtrResult,
EventTarget* aOwner,
already_AddRefed<TimeEvent>
NS_NewDOMTimeEvent(EventTarget* aOwner,
nsPresContext* aPresContext,
InternalSMILTimeEvent* aEvent)
{
TimeEvent* it = new TimeEvent(aOwner, aPresContext, aEvent);
NS_ADDREF(it);
*aInstancePtrResult = static_cast<Event*>(it);
return NS_OK;
nsRefPtr<TimeEvent> it = new TimeEvent(aOwner, aPresContext, aEvent);
return it.forget();
}

5
dom/smil/TimeEvent.h
View File

@@ -63,4 +63,9 @@ private:
} // namespace dom
} // namespace mozilla
already_AddRefed<mozilla::dom::TimeEvent>
NS_NewDOMTimeEvent(mozilla::dom::EventTarget* aOwner,
nsPresContext* aPresContext,
mozilla::InternalSMILTimeEvent* aEvent);
#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/. */
#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/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 dom {
@@ -86,12 +89,7 @@ SpeakerManager::DispatchSimpleEvent(const nsAString& aStr)
return;
}
nsCOMPtr<nsIDOMEvent> event;
rv = NS_NewDOMEvent(getter_AddRefs(event), this, nullptr, nullptr);
if (NS_FAILED(rv)) {
NS_WARNING("Failed to create the error event!!!");
return;
}
nsRefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
rv = event->InitEvent(aStr, false, false);
if (NS_FAILED(rv)) {

13
dom/svg/SVGZoomEvent.cpp
View File

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

5
dom/svg/SVGZoomEvent.h
View File

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

10
dom/workers/ServiceWorkerManager.cpp
View File

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

17
dom/workers/WorkerPrivate.cpp
View File

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

11
dom/workers/XMLHttpRequest.cpp
View File

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

17
dom/xml/nsXMLPrettyPrinter.cpp
View File

@@ -23,7 +23,7 @@
#include "mozilla/Preferences.h"
#include "nsIDocument.h"
#include "nsVariant.h"
#include "nsIDOMCustomEvent.h"
#include "mozilla/dom/CustomEvent.h"
using namespace mozilla;
using namespace mozilla::dom;
@@ -156,22 +156,19 @@ nsXMLPrettyPrinter::PrettyPrint(nsIDocument* aDocument,
NS_ENSURE_SUCCESS(rv, rv);
// Fire an event at the bound element to pass it |resultFragment|.
nsCOMPtr<nsIDOMEvent> domEvent;
rv = NS_NewDOMCustomEvent(getter_AddRefs(domEvent), rootCont,
nullptr, nullptr);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIDOMCustomEvent> customEvent = do_QueryInterface(domEvent);
MOZ_ASSERT(customEvent);
nsRefPtr<CustomEvent> event =
NS_NewDOMCustomEvent(rootCont, nullptr, nullptr);
MOZ_ASSERT(event);
nsCOMPtr<nsIWritableVariant> resultFragmentVariant = new nsVariant();
rv = resultFragmentVariant->SetAsISupports(resultFragment);
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,
/* detail = */ resultFragmentVariant);
NS_ENSURE_SUCCESS(rv, rv);
customEvent->SetTrusted(true);
event->SetTrusted(true);
bool dummy;
rv = rootCont->DispatchEvent(domEvent, &dummy);
rv = rootCont->DispatchEvent(static_cast<Event*>(event), &dummy);
NS_ENSURE_SUCCESS(rv, rv);
// 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 "Layers.h"
#include "ClientLayerManager.h"
#include "nsIDOMEvent.h"
#include "mozilla/dom/NotifyPaintEvent.h"
#include "gfxPrefs.h"
#include "nsIDOMChromeWindow.h"
#include "nsFrameLoader.h"
@@ -2255,23 +2255,21 @@ nsPresContext::FireDOMPaintEvent(nsInvalidateRequestList* aList)
}
// Events sent to the window get propagated to the chrome event handler
// automatically.
nsCOMPtr<nsIDOMEvent> event;
//
// 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
// it won't be blocking app execution though).
NS_NewDOMNotifyPaintEvent(getter_AddRefs(event), eventTarget, this, nullptr,
NS_AFTERPAINT, aList);
if (!event) {
return;
}
nsRefPtr<NotifyPaintEvent> event =
NS_NewDOMNotifyPaintEvent(eventTarget, this, nullptr, NS_AFTERPAINT,
aList);
// 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
// logically the event target.
event->SetTarget(eventTarget);
event->SetTrusted(true);
EventDispatcher::DispatchDOMEvent(dispatchTarget, nullptr, event, this,
nullptr);
EventDispatcher::DispatchDOMEvent(dispatchTarget, nullptr,
static_cast<Event*>(event), this, nullptr);
}
static bool

7
layout/xul/nsMenuFrame.cpp
View File

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