dom/events/JSEventHandler.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef mozilla_JSEventHandler_h_
   8 #define mozilla_JSEventHandler_h_
   9
  10 #include "mozilla/Attributes.h"
  11 #include "mozilla/MemoryReporting.h"
  12 #include "mozilla/dom/EventHandlerBinding.h"
  13 #include "nsCOMPtr.h"
  14 #include "nsCycleCollectionParticipant.h"
  15 #include "nsAtom.h"
  16 #include "nsIDOMEventListener.h"
  17 #include "nsIScriptContext.h"
  18
  19 namespace mozilla {
  20 namespace dom {
  21 class EventTarget;
  22 }  // namespace dom
  23
  24 class TypedEventHandler {
  25  public:
  26   enum HandlerType {
  27     eUnset = 0,
  28     eNormal = 0x1,
  29     eOnError = 0x2,
  30     eOnBeforeUnload = 0x3,
  31     eTypeBits = 0x3
  32   };
  33
  34   TypedEventHandler() : mBits(0) {}
  35
  36   explicit TypedEventHandler(dom::EventHandlerNonNull* aHandler) : mBits(0) {
  37     Assign(aHandler, eNormal);
  38   }
  39
  40   explicit TypedEventHandler(dom::OnErrorEventHandlerNonNull* aHandler)
  41       : mBits(0) {
  42     Assign(aHandler, eOnError);
  43   }
  44
  45   explicit TypedEventHandler(dom::OnBeforeUnloadEventHandlerNonNull* aHandler)
  46       : mBits(0) {
  47     Assign(aHandler, eOnBeforeUnload);
  48   }
  49
  50   TypedEventHandler(const TypedEventHandler& aOther) {
  51     if (aOther.HasEventHandler()) {
  52       // Have to make sure we take our own ref
  53       Assign(aOther.Ptr(), aOther.Type());
  54     } else {
  55       mBits = 0;
  56     }
  57   }
  58
  59   ~TypedEventHandler() { ReleaseHandler(); }
  60
  61   HandlerType Type() const { return HandlerType(mBits & eTypeBits); }
  62
  63   bool HasEventHandler() const { return !!Ptr(); }
  64
  65   void SetHandler(const TypedEventHandler& aHandler) {
  66     if (aHandler.HasEventHandler()) {
  67       ReleaseHandler();
  68       Assign(aHandler.Ptr(), aHandler.Type());
  69     } else {
  70       ForgetHandler();
  71     }
  72   }
  73
  74   dom::EventHandlerNonNull* NormalEventHandler() const {
  75     MOZ_ASSERT(Type() == eNormal && Ptr());
  76     return reinterpret_cast<dom::EventHandlerNonNull*>(Ptr());
  77   }
  78
  79   void SetHandler(dom::EventHandlerNonNull* aHandler) {
  80     ReleaseHandler();
  81     Assign(aHandler, eNormal);
  82   }
  83
  84   dom::OnBeforeUnloadEventHandlerNonNull* OnBeforeUnloadEventHandler() const {
  85     MOZ_ASSERT(Type() == eOnBeforeUnload);
  86     return reinterpret_cast<dom::OnBeforeUnloadEventHandlerNonNull*>(Ptr());
  87   }
  88
  89   void SetHandler(dom::OnBeforeUnloadEventHandlerNonNull* aHandler) {
  90     ReleaseHandler();
  91     Assign(aHandler, eOnBeforeUnload);
  92   }
  93
  94   dom::OnErrorEventHandlerNonNull* OnErrorEventHandler() const {
  95     MOZ_ASSERT(Type() == eOnError);
  96     return reinterpret_cast<dom::OnErrorEventHandlerNonNull*>(Ptr());
  97   }
  98
  99   void SetHandler(dom::OnErrorEventHandlerNonNull* aHandler) {
 100     ReleaseHandler();
 101     Assign(aHandler, eOnError);
 102   }
 103
 104   dom::CallbackFunction* Ptr() const {
 105     // Have to cast eTypeBits so we don't have to worry about
 106     // promotion issues after the bitflip.
 107     return reinterpret_cast<dom::CallbackFunction*>(mBits &
 108                                                     ~uintptr_t(eTypeBits));
 109   }
 110
 111   void ForgetHandler() {
 112     ReleaseHandler();
 113     mBits = 0;
 114   }
 115
 116   bool operator==(const TypedEventHandler& aOther) const {
 117     return Ptr() && aOther.Ptr() &&
 118            Ptr()->CallbackPreserveColor() ==
 119                aOther.Ptr()->CallbackPreserveColor();
 120   }
 121
 122  private:
 123   void operator=(const TypedEventHandler&) = delete;
 124
 125   void ReleaseHandler() {
 126     nsISupports* ptr = Ptr();
 127     NS_IF_RELEASE(ptr);
 128   }
 129
 130   void Assign(nsISupports* aHandler, HandlerType aType) {
 131     MOZ_ASSERT(aHandler, "Must have handler");
 132     NS_ADDREF(aHandler);
 133     mBits = uintptr_t(aHandler) | uintptr_t(aType);
 134   }
 135
 136   uintptr_t mBits;
 137 };
 138
 139 /**
 140  * Implemented by script event listeners. Used to retrieve the script object
 141  * corresponding to the event target and the handler itself.
 142  *
 143  * Note, mTarget is a raw pointer and the owner of the JSEventHandler object
 144  * is expected to call Disconnect()!
 145  */
 146
 147 #define NS_JSEVENTHANDLER_IID                        \
 148   {                                                  \
 149     0x4f486881, 0x1956, 0x4079, {                    \
 150       0x8c, 0xa0, 0xf3, 0xbd, 0x60, 0x5c, 0xc2, 0x79 \
 151     }                                                \
 152   }
 153
 154 class JSEventHandler : public nsIDOMEventListener {
 155  public:
 156   NS_DECLARE_STATIC_IID_ACCESSOR(NS_JSEVENTHANDLER_IID)
 157
 158   JSEventHandler(dom::EventTarget* aTarget, nsAtom* aType,
 159                  const TypedEventHandler& aTypedHandler);
 160
 161   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
 162
 163   // nsIDOMEventListener interface
 164   NS_DECL_NSIDOMEVENTLISTENER
 165
 166   void Disconnect() { mTarget = nullptr; }
 167
 168   const TypedEventHandler& GetTypedEventHandler() const {
 169     return mTypedHandler;
 170   }
 171
 172   void ForgetHandler() { mTypedHandler.ForgetHandler(); }
 173
 174   nsAtom* EventName() const { return mEventName; }
 175
 176   // Set a handler for this event listener.  The handler must already
 177   // be bound to the right target.
 178   void SetHandler(const TypedEventHandler& aTypedHandler) {
 179     mTypedHandler.SetHandler(aTypedHandler);
 180   }
 181   void SetHandler(dom::EventHandlerNonNull* aHandler) {
 182     mTypedHandler.SetHandler(aHandler);
 183   }
 184   void SetHandler(dom::OnBeforeUnloadEventHandlerNonNull* aHandler) {
 185     mTypedHandler.SetHandler(aHandler);
 186   }
 187   void SetHandler(dom::OnErrorEventHandlerNonNull* aHandler) {
 188     mTypedHandler.SetHandler(aHandler);
 189   }
 190
 191   size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const {
 192     return 0;
 193
 194     // Measurement of the following members may be added later if DMD finds it
 195     // is worthwhile:
 196     // - mTarget
 197     //
 198     // The following members are not measured:
 199     // - mTypedHandler: may be shared with others
 200     // - mEventName: shared with others
 201   }
 202
 203   size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) {
 204     return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
 205   }
 206
 207   NS_DECL_CYCLE_COLLECTION_SKIPPABLE_CLASS(JSEventHandler)
 208
 209   bool IsBlackForCC();
 210
 211  protected:
 212   virtual ~JSEventHandler();
 213
 214   dom::EventTarget* mTarget;
 215   RefPtr<nsAtom> mEventName;
 216   TypedEventHandler mTypedHandler;
 217 };
 218
 219 NS_DEFINE_STATIC_IID_ACCESSOR(JSEventHandler, NS_JSEVENTHANDLER_IID)
 220
 221 }  // namespace mozilla
 222
 223 /**
 224  * Factory function.  aHandler must already be bound to aTarget.
 225  * aContext is allowed to be null if aHandler is already set up.
 226  */
 227 nsresult NS_NewJSEventHandler(mozilla::dom::EventTarget* aTarget, nsAtom* aType,
 228                               const mozilla::TypedEventHandler& aTypedHandler,
 229                               mozilla::JSEventHandler** aReturn);
 230
 231 #endif  // mozilla_JSEventHandler_h_