bool
nsAutoWindowStateHelper::DispatchEventToChrome(const char* aEventName)
{
// XXXbz should we skip dispatching the event if the inner changed?
// That is, should we store both the inner and the outer?
if (!mWindow) {
return true;
}
// The functions of nsContentUtils do not provide the required behavior,
// so the following is inlined.
nsIDocument* doc = mWindow->GetExtantDoc();
if (!doc) {
return true;
}
ErrorResult rv;
RefPtr<Event> event = doc->CreateEvent(NS_LITERAL_STRING("Events"), rv);
if (rv.Failed()) {
return false;
}
event->InitEvent(NS_ConvertASCIItoUTF16(aEventName), true, true);
event->SetTrusted(true);
event->GetInternalNSEvent()->mFlags.mOnlyChromeDispatch = true;
nsCOMPtr<EventTarget> target = do_QueryInterface(mWindow);
bool defaultActionEnabled;
target->DispatchEvent(event, &defaultActionEnabled);
return defaultActionEnabled;
}
/* static */ already_AddRefed<MessageEvent>
MessageEvent::Constructor(EventTarget* aEventTarget,
const nsAString& aType,
const MessageEventInit& aParam)
{
RefPtr<MessageEvent> event = new MessageEvent(aEventTarget, nullptr, nullptr);
event->InitEvent(aType, aParam.mBubbles, aParam.mCancelable);
bool trusted = event->Init(aEventTarget);
event->SetTrusted(trusted);
event->mData = aParam.mData;
mozilla::HoldJSObjects(event.get());
event->mOrigin = aParam.mOrigin;
event->mLastEventId = aParam.mLastEventId;
if (!aParam.mSource.IsNull()) {
if (aParam.mSource.Value().IsWindowProxy()) {
event->mWindowSource = aParam.mSource.Value().GetAsWindowProxy();
} else if (aParam.mSource.Value().IsMessagePort()) {
event->mPortSource = aParam.mSource.Value().GetAsMessagePort();
} else {
event->mServiceWorkerSource = aParam.mSource.Value().GetAsServiceWorker();
}
MOZ_ASSERT(event->mWindowSource || event->mPortSource || event->mServiceWorkerSource);
}
event->mPorts.AppendElements(aParam.mPorts);
return event.forget();
}
nsresult
nsDOMOfflineResourceList::SendEvent(const nsAString &aEventName)
{
// Don't send events to closed windows
if (!GetOwner()) {
return NS_OK;
}
if (!GetOwner()->GetDocShell()) {
return NS_OK;
}
RefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
event->InitEvent(aEventName, false, true);
// We assume anyone that managed to call SendEvent is trusted
event->SetTrusted(true);
// If the window is frozen or we're still catching up on events that were
// queued while frozen, save the event for later.
if (GetOwner()->IsFrozen() || mPendingEvents.Count() > 0) {
mPendingEvents.AppendObject(event);
return NS_OK;
}
bool dummy;
DispatchEvent(event, &dummy);
return NS_OK;
}
already_AddRefed<MediaEncryptedEvent>
MediaEncryptedEvent::Constructor(const GlobalObject& aGlobal,
const nsAString& aType,
const MediaKeyNeededEventInit& aEventInitDict,
ErrorResult& aRv)
{
nsCOMPtr<EventTarget> owner = do_QueryInterface(aGlobal.GetAsSupports());
RefPtr<MediaEncryptedEvent> e = new MediaEncryptedEvent(owner);
bool trusted = e->Init(owner);
e->InitEvent(aType, aEventInitDict.mBubbles, aEventInitDict.mCancelable);
e->mInitDataType = aEventInitDict.mInitDataType;
if (!aEventInitDict.mInitData.IsNull()) {
const auto& a = aEventInitDict.mInitData.Value();
a.ComputeLengthAndData();
e->mInitData = ArrayBuffer::Create(aGlobal.Context(),
a.Length(),
a.Data());
if (!e->mInitData) {
aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
return nullptr;
}
}
e->SetTrusted(trusted);
return e.forget();
}
void
nsDeviceSensors::FireDOMProximityEvent(mozilla::dom::EventTarget* aTarget,
double aValue,
double aMin,
double aMax)
{
DeviceProximityEventInit init;
init.mBubbles = true;
init.mCancelable = false;
init.mValue = aValue;
init.mMin = aMin;
init.mMax = aMax;
RefPtr<DeviceProximityEvent> event =
DeviceProximityEvent::Constructor(aTarget,
NS_LITERAL_STRING("deviceproximity"),
init);
event->SetTrusted(true);
bool defaultActionEnabled;
aTarget->DispatchEvent(event, &defaultActionEnabled);
// Some proximity sensors only support a binary near or
// far measurement. In this case, the sensor should report
// its maximum range value in the far state and a lesser
// value in the near state.
bool near = (aValue < aMax);
if (mIsUserProximityNear != near) {
mIsUserProximityNear = near;
FireDOMUserProximityEvent(aTarget, mIsUserProximityNear);
}
}
void
nsPerformance::DispatchBufferFullEvent()
{
RefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
// it bubbles, and it isn't cancelable
event->InitEvent(NS_LITERAL_STRING("resourcetimingbufferfull"), true, false);
event->SetTrusted(true);
DispatchDOMEvent(nullptr, event, nullptr, nullptr);
}
nsresult
nsDOMDataChannel::DoOnMessageAvailable(const nsACString& aData,
bool aBinary)
{
MOZ_ASSERT(NS_IsMainThread());
LOG(("DoOnMessageAvailable%s\n",aBinary ? ((mBinaryType == DC_BINARY_TYPE_BLOB) ? " (blob)" : " (binary)") : ""));
nsresult rv = CheckInnerWindowCorrectness();
if (NS_FAILED(rv)) {
return NS_OK;
}
AutoJSAPI jsapi;
if (NS_WARN_IF(!jsapi.Init(GetOwner()))) {
return NS_ERROR_FAILURE;
}
JSContext* cx = jsapi.cx();
JS::Rooted<JS::Value> jsData(cx);
if (aBinary) {
if (mBinaryType == DC_BINARY_TYPE_BLOB) {
rv = nsContentUtils::CreateBlobBuffer(cx, GetOwner(), aData, &jsData);
NS_ENSURE_SUCCESS(rv, rv);
} else if (mBinaryType == DC_BINARY_TYPE_ARRAYBUFFER) {
JS::Rooted<JSObject*> arrayBuf(cx);
rv = nsContentUtils::CreateArrayBuffer(cx, aData, arrayBuf.address());
NS_ENSURE_SUCCESS(rv, rv);
jsData.setObject(*arrayBuf);
} else {
NS_RUNTIMEABORT("Unknown binary type!");
return NS_ERROR_UNEXPECTED;
}
} else {
NS_ConvertUTF8toUTF16 utf16data(aData);
JSString* jsString = JS_NewUCStringCopyN(cx, utf16data.get(), utf16data.Length());
NS_ENSURE_TRUE(jsString, NS_ERROR_FAILURE);
jsData.setString(jsString);
}
RefPtr<MessageEvent> event = NS_NewDOMMessageEvent(this, nullptr, 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, static_cast<Event*>(event), nullptr, nullptr);
if (NS_FAILED(rv)) {
NS_WARNING("Failed to dispatch the message event!!!");
}
return rv;
}
void HTMLMarqueeElement::DispatchEventToShadowRoot(
const nsAString& aEventTypeArg) {
// Dispatch the event to the UA Widget Shadow Root, make it inaccessible to
// document.
RefPtr<nsINode> shadow = GetShadowRoot();
MOZ_ASSERT(shadow);
RefPtr<Event> event = new Event(shadow, nullptr, nullptr);
event->InitEvent(aEventTypeArg, false, false);
event->SetTrusted(true);
shadow->DispatchEvent(*event, IgnoreErrors());
}
void
TextTrackList::CreateAndDispatchChangeEvent()
{
RefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
event->InitEvent(NS_LITERAL_STRING("change"), false, false);
event->SetTrusted(true);
nsCOMPtr<nsIRunnable> eventRunner = new TrackEventRunner(this, event);
NS_DispatchToMainThread(eventRunner);
}
void nsPluginArray::NotifyHiddenPluginTouched(nsPluginElement* aHiddenElement)
{
HiddenPluginEventInit init;
init.mTag = aHiddenElement->PluginTag();
nsCOMPtr<nsIDocument> doc = aHiddenElement->GetParentObject()->GetDoc();
RefPtr<HiddenPluginEvent> event =
HiddenPluginEvent::Constructor(doc, NS_LITERAL_STRING("HiddenPlugin"), init);
event->SetTarget(doc);
event->SetTrusted(true);
event->WidgetEventPtr()->mFlags.mOnlyChromeDispatch = true;
doc->DispatchEvent(*event);
}
already_AddRefed<SpeechRecognitionError>
SpeechRecognitionError::Constructor(const GlobalObject& aGlobal,
const nsAString& aType,
const SpeechRecognitionErrorInit& aParam,
ErrorResult& aRv)
{
nsCOMPtr<mozilla::dom::EventTarget> t = do_QueryInterface(aGlobal.GetAsSupports());
RefPtr<SpeechRecognitionError> e = new SpeechRecognitionError(t, nullptr, nullptr);
bool trusted = e->Init(t);
e->InitSpeechRecognitionError(aType, aParam.mBubbles, aParam.mCancelable, aParam.mError, aParam.mMessage);
e->SetTrusted(trusted);
return e.forget();
}
void
DOMRequest::FireEvent(const nsAString& aType, bool aBubble, bool aCancelable)
{
if (NS_FAILED(CheckInnerWindowCorrectness())) {
return;
}
RefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
event->InitEvent(aType, aBubble, aCancelable);
event->SetTrusted(true);
bool dummy;
DispatchEvent(event, &dummy);
}
already_AddRefed<CustomEvent>
CustomEvent::Constructor(const GlobalObject& aGlobal,
const nsAString& aType,
const CustomEventInit& aParam,
ErrorResult& aRv)
{
nsCOMPtr<mozilla::dom::EventTarget> t = do_QueryInterface(aGlobal.GetAsSupports());
RefPtr<CustomEvent> e = new CustomEvent(t, nullptr, nullptr);
bool trusted = e->Init(t);
JS::Rooted<JS::Value> detail(aGlobal.Context(), aParam.mDetail);
e->InitCustomEvent(aGlobal.Context(), aType, aParam.mBubbles, aParam.mCancelable, detail, aRv);
e->SetTrusted(trusted);
return e.forget();
}
/* static */ already_AddRefed<MessageEvent>
MessageEvent::Constructor(EventTarget* aEventTarget,
const nsAString& aType,
const MessageEventInit& aParam,
ErrorResult& aRv)
{
RefPtr<MessageEvent> event = new MessageEvent(aEventTarget, nullptr, nullptr);
aRv = event->InitEvent(aType, aParam.mBubbles, aParam.mCancelable);
if (aRv.Failed()) {
return nullptr;
}
bool trusted = event->Init(aEventTarget);
event->SetTrusted(trusted);
event->mData = aParam.mData;
mozilla::HoldJSObjects(event.get());
if (aParam.mOrigin.WasPassed()) {
event->mOrigin = aParam.mOrigin.Value();
}
if (aParam.mLastEventId.WasPassed()) {
event->mLastEventId = aParam.mLastEventId.Value();
}
if (!aParam.mSource.IsNull()) {
if (aParam.mSource.Value().IsWindow()) {
event->mWindowSource = aParam.mSource.Value().GetAsWindow();
} else {
event->mPortSource = aParam.mSource.Value().GetAsMessagePort();
}
MOZ_ASSERT(event->mWindowSource || event->mPortSource);
}
if (aParam.mPorts.WasPassed() && !aParam.mPorts.Value().IsNull()) {
nsTArray<RefPtr<MessagePort>> ports;
for (uint32_t i = 0, len = aParam.mPorts.Value().Value().Length(); i < len; ++i) {
ports.AppendElement(aParam.mPorts.Value().Value()[i].get());
}
event->mPorts = new MessagePortList(static_cast<Event*>(event), ports);
}
return event.forget();
}
already_AddRefed<FocusEvent>
FocusEvent::Constructor(const GlobalObject& aGlobal,
const nsAString& aType,
const FocusEventInit& aParam,
ErrorResult& aRv)
{
nsCOMPtr<EventTarget> t = do_QueryInterface(aGlobal.GetAsSupports());
RefPtr<FocusEvent> e = new FocusEvent(t, nullptr, nullptr);
bool trusted = e->Init(t);
e->InitFocusEvent(aType, aParam.mBubbles, aParam.mCancelable, aParam.mView,
aParam.mDetail, aParam.mRelatedTarget);
e->SetTrusted(trusted);
e->SetComposed(aParam.mComposed);
return e.forget();
}
void
TouchCaret::DispatchTapEvent()
{
nsCOMPtr<nsIPresShell> presShell = do_QueryReferent(mPresShell);
if (!presShell) {
return;
}
RefPtr<nsCaret> caret = presShell->GetCaret();
if (!caret) {
return;
}
dom::Selection* sel = static_cast<dom::Selection*>(caret->GetSelection());
if (!sel) {
return;
}
nsIDocument* doc = presShell->GetDocument();
MOZ_ASSERT(doc);
dom::SelectionStateChangedEventInit init;
init.mBubbles = true;
// XXX: Do we need to flush layout?
presShell->FlushPendingNotifications(Flush_Layout);
nsRect rect = nsLayoutUtils::GetSelectionBoundingRect(sel);
RefPtr<dom::DOMRect>domRect = new dom::DOMRect(ToSupports(doc));
domRect->SetLayoutRect(rect);
init.mBoundingClientRect = domRect;
init.mVisible = false;
sel->Stringify(init.mSelectedText);
dom::Sequence<dom::SelectionState> state;
state.AppendElement(dom::SelectionState::Taponcaret, fallible);
init.mStates = state;
RefPtr<dom::SelectionStateChangedEvent> event =
dom::SelectionStateChangedEvent::Constructor(doc, NS_LITERAL_STRING("mozselectionstatechanged"), init);
event->SetTrusted(true);
event->GetInternalNSEvent()->mFlags.mOnlyChromeDispatch = true;
bool ret;
doc->DispatchEvent(event, &ret);
}
NS_IMETHODIMP
TCPServerSocket::OnStopListening(nsIServerSocket* aServer, nsresult aStatus)
{
if (aStatus != NS_BINDING_ABORTED) {
RefPtr<Event> event = new Event(GetOwner());
event->InitEvent(NS_LITERAL_STRING("error"), false, false);
event->SetTrusted(true);
bool dummy;
DispatchEvent(event, &dummy);
NS_WARNING("Server socket was closed by unexpected reason.");
return NS_ERROR_FAILURE;
}
mServerSocket = nullptr;
return NS_OK;
}
void
nsDeviceSensors::FireDOMLightEvent(mozilla::dom::EventTarget* aTarget,
double aValue)
{
DeviceLightEventInit init;
init.mBubbles = true;
init.mCancelable = false;
init.mValue = aValue;
RefPtr<DeviceLightEvent> event =
DeviceLightEvent::Constructor(aTarget, NS_LITERAL_STRING("devicelight"), init);
event->SetTrusted(true);
bool defaultActionEnabled;
aTarget->DispatchEvent(event, &defaultActionEnabled);
}
/* static */ already_AddRefed<SharedMapChangeEvent>
SharedMapChangeEvent::Constructor(EventTarget* aEventTarget,
const nsAString& aType,
const MozSharedMapChangeEventInit& aInit)
{
RefPtr<SharedMapChangeEvent> event = new SharedMapChangeEvent(aEventTarget);
bool trusted = event->Init(aEventTarget);
event->InitEvent(aType, aInit.mBubbles, aInit.mCancelable);
event->SetTrusted(trusted);
event->SetComposed(aInit.mComposed);
event->mChangedKeys = aInit.mChangedKeys;
return event.forget();
}
// static
already_AddRefed<TouchEvent> TouchEvent::Constructor(
const GlobalObject& aGlobal, const nsAString& aType,
const TouchEventInit& aParam, ErrorResult& aRv) {
nsCOMPtr<EventTarget> t = do_QueryInterface(aGlobal.GetAsSupports());
RefPtr<TouchEvent> e = new TouchEvent(t, nullptr, nullptr);
bool trusted = e->Init(t);
RefPtr<TouchList> touches = e->CopyTouches(aParam.mTouches);
RefPtr<TouchList> targetTouches = e->CopyTouches(aParam.mTargetTouches);
RefPtr<TouchList> changedTouches = e->CopyTouches(aParam.mChangedTouches);
e->InitTouchEvent(aType, aParam.mBubbles, aParam.mCancelable, aParam.mView,
aParam.mDetail, aParam.mCtrlKey, aParam.mAltKey,
aParam.mShiftKey, aParam.mMetaKey, touches, targetTouches,
changedTouches);
e->SetTrusted(trusted);
e->SetComposed(aParam.mComposed);
return e.forget();
}
NS_IMETHODIMP
AsyncEventDispatcher::Run()
{
RefPtr<Event> event = mEvent ? mEvent->InternalDOMEvent() : nullptr;
if (!event) {
event = NS_NewDOMEvent(mTarget, nullptr, nullptr);
event->InitEvent(mEventType, mBubbles, false);
event->SetTrusted(true);
}
if (mOnlyChromeDispatch) {
MOZ_ASSERT(event->IsTrusted());
event->WidgetEventPtr()->mFlags.mOnlyChromeDispatch = true;
}
bool dummy;
mTarget->DispatchEvent(event, &dummy);
return NS_OK;
}
nsresult
nsDOMDataChannel::OnSimpleEvent(nsISupports* aContext, const nsAString& aName)
{
MOZ_ASSERT(NS_IsMainThread());
nsresult rv = CheckInnerWindowCorrectness();
if (NS_FAILED(rv)) {
return NS_OK;
}
RefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
event->InitEvent(aName, false, false);
event->SetTrusted(true);
return DispatchDOMEvent(nullptr, event, nullptr, nullptr);
}
/*static*/ already_AddRefed<FetchEvent>
FetchEvent::Constructor(const GlobalObject& aGlobal,
const nsAString& aType,
const FetchEventInit& aOptions,
ErrorResult& aRv)
{
RefPtr<EventTarget> owner = do_QueryObject(aGlobal.GetAsSupports());
MOZ_ASSERT(owner);
RefPtr<FetchEvent> e = new FetchEvent(owner);
bool trusted = e->Init(owner);
e->InitEvent(aType, aOptions.mBubbles, aOptions.mCancelable);
e->SetTrusted(trusted);
e->mRequest = aOptions.mRequest;
e->mClientId = aOptions.mClientId;
e->mIsReload = aOptions.mIsReload;
return e.forget();
}
void
nsDeviceSensors::FireDOMUserProximityEvent(mozilla::dom::EventTarget* aTarget,
bool aNear)
{
UserProximityEventInit init;
init.mBubbles = true;
init.mCancelable = false;
init.mNear = aNear;
RefPtr<UserProximityEvent> event =
UserProximityEvent::Constructor(aTarget,
NS_LITERAL_STRING("userproximity"),
init);
event->SetTrusted(true);
bool defaultActionEnabled;
aTarget->DispatchEvent(event, &defaultActionEnabled);
}
void
TCPServerSocket::FireEvent(const nsAString& aType, TCPSocket* aSocket)
{
TCPServerSocketEventInit init;
init.mBubbles = false;
init.mCancelable = false;
init.mSocket = aSocket;
RefPtr<TCPServerSocketEvent> event =
TCPServerSocketEvent::Constructor(this, aType, init);
event->SetTrusted(true);
bool dummy;
DispatchEvent(event, &dummy);
if (mServerBridgeParent) {
mServerBridgeParent->OnConnect(event);
}
}
already_AddRefed<BluetoothLeDeviceEvent>
BluetoothLeDeviceEvent::Constructor(
mozilla::dom::EventTarget* aOwner,
const nsAString& aType,
BluetoothDevice* const aDevice,
const int16_t aRssi,
const nsTArray<uint8_t>& aScanRecord)
{
RefPtr<BluetoothLeDeviceEvent> e = new BluetoothLeDeviceEvent(aOwner);
bool trusted = e->Init(aOwner);
e->InitEvent(aType, false, false);
e->mDevice = aDevice;
e->mRssi = aRssi;
e->mRawScanRecord = aScanRecord;
e->SetTrusted(trusted);
return e.forget();
}
void
nsDeviceSensors::FireDOMOrientationEvent(EventTarget* aTarget,
double aAlpha,
double aBeta,
double aGamma,
bool aIsAbsolute)
{
DeviceOrientationEventInit init;
init.mBubbles = true;
init.mCancelable = false;
init.mAlpha.SetValue(aAlpha);
init.mBeta.SetValue(aBeta);
init.mGamma.SetValue(aGamma);
init.mAbsolute = aIsAbsolute;
auto Dispatch = [&](EventTarget* aEventTarget, const nsAString& aType)
{
RefPtr<DeviceOrientationEvent> event =
DeviceOrientationEvent::Constructor(aEventTarget, aType, init);
event->SetTrusted(true);
bool dummy;
aEventTarget->DispatchEvent(event, &dummy);
};
Dispatch(aTarget, aIsAbsolute ? NS_LITERAL_STRING("absolutedeviceorientation") :
NS_LITERAL_STRING("deviceorientation"));
// This is used to determine whether relative events have been dispatched
// during the current session, in which case we don't dispatch the additional
// compatibility events.
static bool sIsDispatchingRelativeEvents = false;
sIsDispatchingRelativeEvents = sIsDispatchingRelativeEvents || !aIsAbsolute;
// Android devices with SENSOR_GAME_ROTATION_VECTOR support dispatch
// relative events for "deviceorientation" by default, while other platforms
// and devices without such support dispatch absolute events by default.
if (aIsAbsolute && !sIsDispatchingRelativeEvents) {
// For absolute events on devices without support for relative events,
// we need to additionally dispatch type "deviceorientation" to keep
// backwards-compatibility.
Dispatch(aTarget, NS_LITERAL_STRING("deviceorientation"));
}
}
// static
already_AddRefed<DragEvent>
DragEvent::Constructor(const GlobalObject& aGlobal,
const nsAString& aType,
const DragEventInit& aParam,
ErrorResult& aRv)
{
nsCOMPtr<EventTarget> t = do_QueryInterface(aGlobal.GetAsSupports());
RefPtr<DragEvent> e = new DragEvent(t, nullptr, nullptr);
bool trusted = e->Init(t);
e->InitDragEvent(aType, aParam.mBubbles, aParam.mCancelable,
aParam.mView, aParam.mDetail, aParam.mScreenX,
aParam.mScreenY, aParam.mClientX, aParam.mClientY,
aParam.mCtrlKey, aParam.mAltKey, aParam.mShiftKey,
aParam.mMetaKey, aParam.mButton, aParam.mRelatedTarget,
aParam.mDataTransfer);
e->InitializeExtraMouseEventDictionaryMembers(aParam);
e->SetTrusted(trusted);
return e.forget();
}
void
GamepadManager::FireConnectionEvent(EventTarget* aTarget,
Gamepad* aGamepad,
bool aConnected)
{
nsString name = aConnected ? NS_LITERAL_STRING("gamepadconnected") :
NS_LITERAL_STRING("gamepaddisconnected");
GamepadEventInit init;
init.mBubbles = false;
init.mCancelable = false;
init.mGamepad = aGamepad;
RefPtr<GamepadEvent> event =
GamepadEvent::Constructor(aTarget, name, init);
event->SetTrusted(true);
bool defaultActionEnabled = true;
aTarget->DispatchEvent(event, &defaultActionEnabled);
}
nsresult
PresentationRequest::DispatchConnectionAvailableEvent(PresentationConnection* aConnection)
{
PresentationConnectionAvailableEventInit init;
init.mConnection = aConnection;
RefPtr<PresentationConnectionAvailableEvent> event =
PresentationConnectionAvailableEvent::Constructor(this,
NS_LITERAL_STRING("connectionavailable"),
init);
if (NS_WARN_IF(!event)) {
return NS_ERROR_FAILURE;
}
event->SetTrusted(true);
RefPtr<AsyncEventDispatcher> asyncDispatcher =
new AsyncEventDispatcher(this, event);
return asyncDispatcher->PostDOMEvent();
}
