wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity

Bug 984253 part.3 Rename nsEventHandler to mozilla::TypedEventHandler r=smaug

Browse Source
This commit is contained in:
Masayuki Nakano 2014-04-02 11:00:45 +09:00
parent 6a2234c047
commit 24af1645ff
6 changed files with 93 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
dom/events/EventListenerManager.cpp
View File

@ -599,7 +599,7 @@ EventListenerManager::Listener*
EventListenerManager::SetEventHandlerInternal(
nsIAtom* aName,
const nsAString& aTypeString,
const nsEventHandler& aHandler,
const TypedEventHandler& aTypedHandler,
bool aPermitUntrustedEvents)
{
MOZ_ASSERT(aName || !aTypeString.IsEmpty());
@ -615,7 +615,7 @@ EventListenerManager::SetEventHandlerInternal(
nsCOMPtr<nsJSEventListener> jsListener;
NS_NewJSEventHandler(mTarget, aName,
aHandler, getter_AddRefs(jsListener));
aTypedHandler, getter_AddRefs(jsListener));
EventListenerHolder listenerHolder(jsListener);
AddEventListenerInternal(listenerHolder, eventType, aName, aTypeString,
flags, true);
@ -626,9 +626,9 @@ EventListenerManager::SetEventHandlerInternal(
MOZ_ASSERT(jsListener,
"How can we have an event handler with no nsJSEventListener?");
bool same = jsListener->GetHandler() == aHandler;
bool same = jsListener->GetTypedEventHandler() == aTypedHandler;
// Possibly the same listener, but update still the context and scope.
jsListener->SetHandler(aHandler);
jsListener->SetHandler(aTypedHandler);
if (mTarget && !same && aName) {
mTarget->EventListenerRemoved(aName);
mTarget->EventListenerAdded(aName);
@ -636,7 +636,7 @@ EventListenerManager::SetEventHandlerInternal(
}
// Set flag to indicate possible need for compilation later
listener->mHandlerIsString = !aHandler.HasEventHandler();
listener->mHandlerIsString = !aTypedHandler.HasEventHandler();
if (aPermitUntrustedEvents) {
listener->mFlags.mAllowUntrustedEvents = true;
}
@ -747,7 +747,7 @@ EventListenerManager::SetEventHandler(nsIAtom* aName,
Listener* listener = SetEventHandlerInternal(aName,
EmptyString(),
nsEventHandler(),
TypedEventHandler(),
aPermitUntrustedEvents);
if (!aDeferCompilation) {
@ -786,7 +786,8 @@ EventListenerManager::CompileEventHandlerInternal(Listener* aListener,
MOZ_ASSERT(aListener->GetJSListener());
MOZ_ASSERT(aListener->mHandlerIsString, "Why are we compiling a non-string JS listener?");
nsJSEventListener* jsListener = aListener->GetJSListener();
MOZ_ASSERT(!jsListener->GetHandler().HasEventHandler(), "What is there to compile?");
MOZ_ASSERT(!jsListener->GetTypedEventHandler().HasEventHandler(),
"What is there to compile?");
nsresult result = NS_OK;
nsCOMPtr<nsIDocument> doc;
@ -1222,7 +1223,7 @@ EventListenerManager::SetEventHandler(nsIAtom* aEventName,
// Untrusted events are always permitted for non-chrome script
// handlers.
SetEventHandlerInternal(aEventName, aTypeString, nsEventHandler(aHandler),
SetEventHandlerInternal(aEventName, aTypeString, TypedEventHandler(aHandler),
!mIsMainThreadELM ||
!nsContentUtils::IsCallerChrome());
}
@ -1239,7 +1240,7 @@ EventListenerManager::SetEventHandler(OnErrorEventHandlerNonNull* aHandler)
// Untrusted events are always permitted for non-chrome script
// handlers.
SetEventHandlerInternal(nsGkAtoms::onerror, EmptyString(),
nsEventHandler(aHandler),
TypedEventHandler(aHandler),
!nsContentUtils::IsCallerChrome());
} else {
if (!aHandler) {
@ -1249,7 +1250,7 @@ EventListenerManager::SetEventHandler(OnErrorEventHandlerNonNull* aHandler)
// Untrusted events are always permitted.
SetEventHandlerInternal(nullptr, NS_LITERAL_STRING("error"),
nsEventHandler(aHandler), true);
TypedEventHandler(aHandler), true);
}
}
@ -1265,14 +1266,14 @@ EventListenerManager::SetEventHandler(
// Untrusted events are always permitted for non-chrome script
// handlers.
SetEventHandlerInternal(nsGkAtoms::onbeforeunload, EmptyString(),
nsEventHandler(aHandler),
TypedEventHandler(aHandler),
!mIsMainThreadELM ||
!nsContentUtils::IsCallerChrome());
}
const nsEventHandler*
EventListenerManager::GetEventHandlerInternal(nsIAtom* aEventName,
const nsAString& aTypeString)
const TypedEventHandler*
EventListenerManager::GetTypedEventHandler(nsIAtom* aEventName,
const nsAString& aTypeString)
{
uint32_t eventType = nsContentUtils::GetEventId(aEventName);
Listener* listener = FindEventHandler(eventType, aEventName, aTypeString);
@ -1287,12 +1288,8 @@ EventListenerManager::GetEventHandlerInternal(nsIAtom* aEventName,
CompileEventHandlerInternal(listener, nullptr, nullptr);
}
const nsEventHandler& handler = jsListener->GetHandler();
if (handler.HasEventHandler()) {
return &handler;
}
return nullptr;
const TypedEventHandler& typedHandler = jsListener->GetTypedEventHandler();
return typedHandler.HasEventHandler() ? &typedHandler : nullptr;
}
size_t
@ -1318,8 +1315,10 @@ EventListenerManager::MarkForCC()
const Listener& listener = mListeners.ElementAt(i);
nsJSEventListener* jsListener = listener.GetJSListener();
if (jsListener) {
if (jsListener->GetHandler().HasEventHandler()) {
JS::ExposeObjectToActiveJS(jsListener->GetHandler().Ptr()->Callable());
const TypedEventHandler& typedHandler =
jsListener->GetTypedEventHandler();
if (typedHandler.HasEventHandler()) {
JS::ExposeObjectToActiveJS(typedHandler.Ptr()->Callable());
}
} else if (listener.mListenerType == Listener::eWrappedJSListener) {
xpc_TryUnmarkWrappedGrayObject(listener.mListener.GetXPCOMCallback());

27
dom/events/EventListenerManager.h
View File

@ -449,7 +449,7 @@ protected:
*/
Listener* SetEventHandlerInternal(nsIAtom* aName,
const nsAString& aTypeString,
const nsEventHandler& aHandler,
const TypedEventHandler& aHandler,
bool aPermitUntrustedEvents);
bool IsDeviceType(uint32_t aType);
@ -479,27 +479,24 @@ public:
dom::EventHandlerNonNull* GetEventHandler(nsIAtom* aEventName,
const nsAString& aTypeString)
{
const nsEventHandler* handler =
GetEventHandlerInternal(aEventName, aTypeString);
return handler ? handler->EventHandler() : nullptr;
const TypedEventHandler* typedHandler =
GetTypedEventHandler(aEventName, aTypeString);
return typedHandler ? typedHandler->NormalEventHandler() : nullptr;
}
dom::OnErrorEventHandlerNonNull* GetOnErrorEventHandler()
{
const nsEventHandler* handler;
if (mIsMainThreadELM) {
handler = GetEventHandlerInternal(nsGkAtoms::onerror, EmptyString());
} else {
handler = GetEventHandlerInternal(nullptr, NS_LITERAL_STRING("error"));
}
return handler ? handler->OnErrorEventHandler() : nullptr;
const TypedEventHandler* typedHandler = mIsMainThreadELM ?
GetTypedEventHandler(nsGkAtoms::onerror, EmptyString()) :
GetTypedEventHandler(nullptr, NS_LITERAL_STRING("error"));
return typedHandler ? typedHandler->OnErrorEventHandler() : nullptr;
}
dom::OnBeforeUnloadEventHandlerNonNull* GetOnBeforeUnloadEventHandler()
{
const nsEventHandler* handler =
GetEventHandlerInternal(nsGkAtoms::onbeforeunload, EmptyString());
return handler ? handler->OnBeforeUnloadEventHandler() : nullptr;
const TypedEventHandler* typedHandler =
GetTypedEventHandler(nsGkAtoms::onbeforeunload, EmptyString());
return typedHandler ? typedHandler->OnBeforeUnloadEventHandler() : nullptr;
}
protected:
@ -507,7 +504,7 @@ protected:
* Helper method for implementing the various Get*EventHandler above. Will
* return null if we don't have an event handler for this event name.
*/
const nsEventHandler* GetEventHandlerInternal(nsIAtom* aEventName,
const TypedEventHandler* GetTypedEventHandler(nsIAtom* aEventName,
const nsAString& aTypeString);
void AddEventListener(const nsAString& aType,

5
dom/events/EventListenerService.cpp
View File

@ -102,8 +102,9 @@ EventListenerInfo::GetJSVal(JSContext* aCx,
}
nsCOMPtr<nsJSEventListener> jsl = do_QueryInterface(mListener);
if (jsl && jsl->GetHandler().HasEventHandler()) {
JS::Handle<JSObject*> handler(jsl->GetHandler().Ptr()->Callable());
if (jsl && jsl->GetTypedEventHandler().HasEventHandler()) {
JS::Handle<JSObject*> handler =
jsl->GetTypedEventHandler().Ptr()->Callable();
if (handler) {
aAc.construct(aCx, handler);
aJSVal.setObject(*handler);

33
dom/events/JSEventHandler.cpp
View File

@ -45,9 +45,9 @@ using namespace mozilla::dom;
*/
nsJSEventListener::nsJSEventListener(nsISupports *aTarget,
nsIAtom* aType,
const nsEventHandler& aHandler)
const TypedEventHandler& aTypedHandler)
: mEventName(aType)
, mHandler(aHandler)
, mTypedHandler(aTypedHandler)
{
nsCOMPtr<nsISupports> base = do_QueryInterface(aTarget);
mTarget = base.get();
@ -56,7 +56,7 @@ nsJSEventListener::nsJSEventListener(nsISupports *aTarget,
NS_IMPL_CYCLE_COLLECTION_CLASS(nsJSEventListener)
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsJSEventListener)
tmp->mHandler.ForgetHandler();
tmp->mTypedHandler.ForgetHandler();
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INTERNAL(nsJSEventListener)
if (MOZ_UNLIKELY(cb.WantDebugInfo()) && tmp->mEventName) {
@ -68,7 +68,7 @@ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INTERNAL(nsJSEventListener)
} else {
NS_IMPL_CYCLE_COLLECTION_DESCRIBE(nsJSEventListener, tmp->mRefCnt.get())
}
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_RAWPTR(mHandler.Ptr())
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_RAWPTR(mTypedHandler.Ptr())
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
@ -113,15 +113,16 @@ nsJSEventListener::IsBlackForCC()
{
// We can claim to be black if all the things we reference are
// effectively black already.
return !mHandler.HasEventHandler() || !mHandler.Ptr()->HasGrayCallable();
return !mTypedHandler.HasEventHandler() ||
!mTypedHandler.Ptr()->HasGrayCallable();
}
nsresult
nsJSEventListener::HandleEvent(nsIDOMEvent* aEvent)
{
nsCOMPtr<EventTarget> target = do_QueryInterface(mTarget);
if (!target || !mHandler.HasEventHandler() ||
!GetHandler().Ptr()->CallbackPreserveColor()) {
if (!target || !mTypedHandler.HasEventHandler() ||
!GetTypedEventHandler().Ptr()->CallbackPreserveColor()) {
return NS_ERROR_FAILURE;
}
@ -130,11 +131,11 @@ nsJSEventListener::HandleEvent(nsIDOMEvent* aEvent)
bool isChromeHandler =
isMainThread ?
nsContentUtils::GetObjectPrincipal(
GetHandler().Ptr()->CallbackPreserveColor()) ==
GetTypedEventHandler().Ptr()->CallbackPreserveColor()) ==
nsContentUtils::GetSystemPrincipal() :
mozilla::dom::workers::IsCurrentThreadRunningChromeWorker();
if (mHandler.Type() == nsEventHandler::eOnError) {
if (mTypedHandler.Type() == TypedEventHandler::eOnError) {
MOZ_ASSERT_IF(mEventName, mEventName == nsGkAtoms::onerror);
nsString errorMsg, file;
@ -167,7 +168,7 @@ nsJSEventListener::HandleEvent(nsIDOMEvent* aEvent)
}
nsRefPtr<OnErrorEventHandlerNonNull> handler =
mHandler.OnErrorEventHandler();
mTypedHandler.OnErrorEventHandler();
ErrorResult rv;
bool handled = handler->Call(mTarget, msgOrEvent, fileName, lineNumber,
columnNumber, error, rv);
@ -181,11 +182,11 @@ nsJSEventListener::HandleEvent(nsIDOMEvent* aEvent)
return NS_OK;
}
if (mHandler.Type() == nsEventHandler::eOnBeforeUnload) {
if (mTypedHandler.Type() == TypedEventHandler::eOnBeforeUnload) {
MOZ_ASSERT(mEventName == nsGkAtoms::onbeforeunload);
nsRefPtr<OnBeforeUnloadEventHandlerNonNull> handler =
mHandler.OnBeforeUnloadEventHandler();
mTypedHandler.OnBeforeUnloadEventHandler();
ErrorResult rv;
nsString retval;
handler->Call(mTarget, *(aEvent->InternalDOMEvent()), retval, rv);
@ -213,9 +214,9 @@ nsJSEventListener::HandleEvent(nsIDOMEvent* aEvent)
return NS_OK;
}
MOZ_ASSERT(mHandler.Type() == nsEventHandler::eNormal);
MOZ_ASSERT(mTypedHandler.Type() == TypedEventHandler::eNormal);
ErrorResult rv;
nsRefPtr<EventHandlerNonNull> handler = mHandler.EventHandler();
nsRefPtr<EventHandlerNonNull> handler = mTypedHandler.NormalEventHandler();
JS::Value retval =
handler->Call(mTarget, *(aEvent->InternalDOMEvent()), rv);
if (rv.Failed()) {
@ -241,12 +242,12 @@ nsJSEventListener::HandleEvent(nsIDOMEvent* aEvent)
nsresult
NS_NewJSEventHandler(nsISupports* aTarget,
nsIAtom* aEventType,
const nsEventHandler& aHandler,
const TypedEventHandler& aTypedHandler,
nsJSEventListener** aReturn)
{
NS_ENSURE_ARG(aEventType || !NS_IsMainThread());
nsJSEventListener* it =
new nsJSEventListener(aTarget, aEventType, aHandler);
new nsJSEventListener(aTarget, aEventType, aTypedHandler);
NS_ADDREF(*aReturn = it);
return NS_OK;

77
dom/events/JSEventHandler.h
View File

@ -16,15 +16,11 @@
#include "nsIDOMEventListener.h"
#include "nsIScriptContext.h"
class nsEventHandler
namespace mozilla {
class TypedEventHandler
{
public:
typedef mozilla::dom::EventHandlerNonNull EventHandlerNonNull;
typedef mozilla::dom::OnBeforeUnloadEventHandlerNonNull
OnBeforeUnloadEventHandlerNonNull;
typedef mozilla::dom::OnErrorEventHandlerNonNull OnErrorEventHandlerNonNull;
typedef mozilla::dom::CallbackFunction CallbackFunction;
enum HandlerType
{
eUnset = 0,
@ -34,27 +30,27 @@ public:
eTypeBits = 0x3
};
nsEventHandler()
TypedEventHandler()
: mBits(0)
{
}
nsEventHandler(EventHandlerNonNull* aHandler)
TypedEventHandler(dom::EventHandlerNonNull* aHandler)
{
Assign(aHandler, eNormal);
}
nsEventHandler(OnErrorEventHandlerNonNull* aHandler)
TypedEventHandler(dom::OnErrorEventHandlerNonNull* aHandler)
{
Assign(aHandler, eOnError);
}
nsEventHandler(OnBeforeUnloadEventHandlerNonNull* aHandler)
TypedEventHandler(dom::OnBeforeUnloadEventHandlerNonNull* aHandler)
{
Assign(aHandler, eOnBeforeUnload);
}
nsEventHandler(const nsEventHandler& aOther)
TypedEventHandler(const TypedEventHandler& aOther)
{
if (aOther.HasEventHandler()) {
// Have to make sure we take our own ref
@ -64,7 +60,7 @@ public:
}
}
~nsEventHandler()
~TypedEventHandler()
{
ReleaseHandler();
}
@ -79,7 +75,7 @@ public:
return !!Ptr();
}
void SetHandler(const nsEventHandler& aHandler)
void SetHandler(const TypedEventHandler& aHandler)
{
if (aHandler.HasEventHandler()) {
ReleaseHandler();
@ -89,47 +85,48 @@ public:
}
}
EventHandlerNonNull* EventHandler() const
dom::EventHandlerNonNull* NormalEventHandler() const
{
MOZ_ASSERT(Type() == eNormal && Ptr());
return reinterpret_cast<EventHandlerNonNull*>(Ptr());
return reinterpret_cast<dom::EventHandlerNonNull*>(Ptr());
}
void SetHandler(EventHandlerNonNull* aHandler)
void SetHandler(dom::EventHandlerNonNull* aHandler)
{
ReleaseHandler();
Assign(aHandler, eNormal);
}
OnBeforeUnloadEventHandlerNonNull* OnBeforeUnloadEventHandler() const
dom::OnBeforeUnloadEventHandlerNonNull* OnBeforeUnloadEventHandler() const
{
MOZ_ASSERT(Type() == eOnBeforeUnload);
return reinterpret_cast<OnBeforeUnloadEventHandlerNonNull*>(Ptr());
return reinterpret_cast<dom::OnBeforeUnloadEventHandlerNonNull*>(Ptr());
}
void SetHandler(OnBeforeUnloadEventHandlerNonNull* aHandler)
void SetHandler(dom::OnBeforeUnloadEventHandlerNonNull* aHandler)
{
ReleaseHandler();
Assign(aHandler, eOnBeforeUnload);
}
OnErrorEventHandlerNonNull* OnErrorEventHandler() const
dom::OnErrorEventHandlerNonNull* OnErrorEventHandler() const
{
MOZ_ASSERT(Type() == eOnError);
return reinterpret_cast<OnErrorEventHandlerNonNull*>(Ptr());
return reinterpret_cast<dom::OnErrorEventHandlerNonNull*>(Ptr());
}
void SetHandler(OnErrorEventHandlerNonNull* aHandler)
void SetHandler(dom::OnErrorEventHandlerNonNull* aHandler)
{
ReleaseHandler();
Assign(aHandler, eOnError);
}
CallbackFunction* Ptr() const
dom::CallbackFunction* Ptr() const
{
// Have to cast eTypeBits so we don't have to worry about
// promotion issues after the bitflip.
return reinterpret_cast<CallbackFunction*>(mBits & ~uintptr_t(eTypeBits));
return reinterpret_cast<dom::CallbackFunction*>(mBits &
~uintptr_t(eTypeBits));
}
void ForgetHandler()
@ -138,7 +135,7 @@ public:
mBits = 0;
}
bool operator==(const nsEventHandler& aOther) const
bool operator==(const TypedEventHandler& aOther) const
{
return
Ptr() && aOther.Ptr() &&
@ -146,7 +143,7 @@ public:
}
private:
void operator=(const nsEventHandler&) MOZ_DELETE;
void operator=(const TypedEventHandler&) MOZ_DELETE;
void ReleaseHandler()
{
@ -164,6 +161,8 @@ private:
uintptr_t mBits;
};
} // namespace mozilla
/**
* Implemented by script event listeners. Used to retrieve the script object
* corresponding to the event target and the handler itself.
@ -182,7 +181,7 @@ public:
NS_DECLARE_STATIC_IID_ACCESSOR(NS_JSEVENTLISTENER_IID)
nsJSEventListener(nsISupports* aTarget, nsIAtom* aType,
const nsEventHandler& aHandler);
const mozilla::TypedEventHandler& aTypedHandler);
virtual ~nsJSEventListener()
{
@ -204,14 +203,14 @@ public:
mTarget = nullptr;
}
const nsEventHandler& GetHandler() const
const mozilla::TypedEventHandler& GetTypedEventHandler() const
{
return mHandler;
return mTypedHandler;
}
void ForgetHandler()
{
mHandler.ForgetHandler();
mTypedHandler.ForgetHandler();
}
nsIAtom* EventName() const
@ -221,21 +220,21 @@ public:
// Set a handler for this event listener. The handler must already
// be bound to the right target.
void SetHandler(const nsEventHandler& aHandler)
void SetHandler(const mozilla::TypedEventHandler& aTypedHandler)
{
mHandler.SetHandler(aHandler);
mTypedHandler.SetHandler(aTypedHandler);
}
void SetHandler(mozilla::dom::EventHandlerNonNull* aHandler)
{
mHandler.SetHandler(aHandler);
mTypedHandler.SetHandler(aHandler);
}
void SetHandler(mozilla::dom::OnBeforeUnloadEventHandlerNonNull* aHandler)
{
mHandler.SetHandler(aHandler);
mTypedHandler.SetHandler(aHandler);
}
void SetHandler(mozilla::dom::OnErrorEventHandlerNonNull* aHandler)
{
mHandler.SetHandler(aHandler);
mTypedHandler.SetHandler(aHandler);
}
size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
@ -247,7 +246,7 @@ public:
// - mTarget
//
// The following members are not measured:
// - mHandler: may be shared with others
// - mTypedHandler: may be shared with others
// - mEventName: shared with others
}
@ -263,7 +262,7 @@ public:
protected:
nsISupports* mTarget;
nsCOMPtr<nsIAtom> mEventName;
nsEventHandler mHandler;
mozilla::TypedEventHandler mTypedHandler;
};
NS_DEFINE_STATIC_IID_ACCESSOR(nsJSEventListener, NS_JSEVENTLISTENER_IID)
@ -274,7 +273,7 @@ NS_DEFINE_STATIC_IID_ACCESSOR(nsJSEventListener, NS_JSEVENTLISTENER_IID)
*/
nsresult NS_NewJSEventHandler(nsISupports* aTarget,
nsIAtom* aType,
const nsEventHandler& aHandler,
const mozilla::TypedEventHandler& aTypedHandler,
nsJSEventListener** aReturn);
#endif // mozilla_JSEventHandler_h_

4
dom/xbl/nsXBLPrototypeHandler.cpp
View File

@ -322,12 +322,12 @@ nsXBLPrototypeHandler::ExecuteHandler(EventTarget* aTarget,
nsRefPtr<EventHandlerNonNull> handlerCallback =
new EventHandlerNonNull(bound, /* aIncumbentGlobal = */ nullptr);
nsEventHandler eventHandler(handlerCallback);
TypedEventHandler typedHandler(handlerCallback);
// Execute it.
nsCOMPtr<nsJSEventListener> eventListener;
rv = NS_NewJSEventHandler(scriptTarget, onEventAtom,
eventHandler,
typedHandler,
getter_AddRefs(eventListener));
NS_ENSURE_SUCCESS(rv, rv);