dom/svg/DOMSVGNumberList.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 DOM_SVG_DOMSVGNUMBERLIST_H_
   8 #define DOM_SVG_DOMSVGNUMBERLIST_H_
   9
  10 #include "DOMSVGAnimatedNumberList.h"
  11 #include "mozAutoDocUpdate.h"
  12 #include "nsCycleCollectionParticipant.h"
  13 #include "nsDebug.h"
  14 #include "nsTArray.h"
  15 #include "SVGNumberList.h"
  16 #include "mozilla/Attributes.h"
  17 #include "mozilla/RefPtr.h"
  18
  19 namespace mozilla {
  20 class ErrorResult;
  21
  22 namespace dom {
  23 class DOMSVGNumber;
  24 class SVGElement;
  25
  26 //----------------------------------------------------------------------
  27 // Helper class: AutoChangeNumberListNotifier
  28 // Stack-based helper class to pair calls to WillChangeNumberList and
  29 // DidChangeNumberList. Used by DOMSVGNumber and DOMSVGNumberList.
  30 template <class T>
  31 class MOZ_RAII AutoChangeNumberListNotifier : public mozAutoDocUpdate {
  32  public:
  33   explicit AutoChangeNumberListNotifier(T* aValue)
  34       : mozAutoDocUpdate(aValue->Element()->GetComposedDoc(), true),
  35         mValue(aValue) {
  36     MOZ_ASSERT(mValue, "Expecting non-null value");
  37     mEmptyOrOldValue =
  38         mValue->Element()->WillChangeNumberList(mValue->AttrEnum(), *this);
  39   }
  40
  41   ~AutoChangeNumberListNotifier() {
  42     mValue->Element()->DidChangeNumberList(mValue->AttrEnum(), mEmptyOrOldValue,
  43                                            *this);
  44     if (mValue->IsAnimating()) {
  45       mValue->Element()->AnimationNeedsResample();
  46     }
  47   }
  48
  49  private:
  50   T* const mValue;
  51   nsAttrValue mEmptyOrOldValue;
  52 };
  53
  54 /**
  55  * Class DOMSVGNumberList
  56  *
  57  * This class is used to create the DOM tearoff objects that wrap internal
  58  * SVGNumberList objects.
  59  *
  60  * See the architecture comment in DOMSVGAnimatedNumberList.h.
  61  *
  62  * This class is strongly intertwined with DOMSVGAnimatedNumberList and
  63  * DOMSVGNumber. We are a friend of DOMSVGAnimatedNumberList, and are
  64  * responsible for nulling out our DOMSVGAnimatedNumberList's pointer to us
  65  * when we die, essentially making its pointer to us a weak pointer. Similarly,
  66  * our DOMSVGNumber items are friends of us and responsible for nulling out our
  67  * pointers to them.
  68  *
  69  * Our DOM items are created lazily on demand as and when script requests them.
  70  */
  71 class DOMSVGNumberList final : public nsISupports, public nsWrapperCache {
  72   template <class T>
  73   friend class AutoChangeNumberListNotifier;
  74   friend class DOMSVGNumber;
  75
  76   ~DOMSVGNumberList() {
  77     // Our mAList's weak ref to us must be nulled out when we die. If GC has
  78     // unlinked us using the cycle collector code, then that has already
  79     // happened, and mAList is null.
  80     if (mAList) {
  81       (IsAnimValList() ? mAList->mAnimVal : mAList->mBaseVal) = nullptr;
  82     }
  83   }
  84
  85  public:
  86   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
  87   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(DOMSVGNumberList)
  88
  89   DOMSVGNumberList(DOMSVGAnimatedNumberList* aAList,
  90                    const SVGNumberList& aInternalList)
  91       : mAList(aAList) {
  92     // aInternalList must be passed in explicitly because we can't use
  93     // InternalList() here. (Because it depends on IsAnimValList, which depends
  94     // on this object having been assigned to aAList's mBaseVal or mAnimVal,
  95     // which hasn't happened yet.)
  96
  97     InternalListLengthWillChange(aInternalList.Length());  // Sync mItems
  98   }
  99
 100   virtual JSObject* WrapObject(JSContext* cx,
 101                                JS::Handle<JSObject*> aGivenProto) override;
 102
 103   nsISupports* GetParentObject() { return static_cast<nsIContent*>(Element()); }
 104
 105   /**
 106    * This will normally be the same as InternalList().Length(), except if we've
 107    * hit OOM in which case our length will be zero.
 108    */
 109   uint32_t LengthNoFlush() const {
 110     MOZ_ASSERT(
 111         mItems.Length() == 0 || mItems.Length() == InternalList().Length(),
 112         "DOM wrapper's list length is out of sync");
 113     return mItems.Length();
 114   }
 115
 116   /// Called to notify us to synchronize our length and detach excess items.
 117   void InternalListLengthWillChange(uint32_t aNewLength);
 118
 119   /**
 120    * Returns true if our attribute is animating (in which case our animVal is
 121    * not simply a mirror of our baseVal).
 122    */
 123   bool IsAnimating() const { return mAList->IsAnimating(); }
 124   /**
 125    * Returns true if there is an animated list mirroring the base list.
 126    */
 127   bool AnimListMirrorsBaseList() const {
 128     return mAList->mAnimVal && !mAList->IsAnimating();
 129   }
 130
 131   uint32_t NumberOfItems() const {
 132     if (IsAnimValList()) {
 133       Element()->FlushAnimations();
 134     }
 135     return LengthNoFlush();
 136   }
 137   void Clear(ErrorResult& error);
 138   already_AddRefed<DOMSVGNumber> Initialize(DOMSVGNumber& aItem,
 139                                             ErrorResult& error);
 140   already_AddRefed<DOMSVGNumber> GetItem(uint32_t index, ErrorResult& error);
 141   already_AddRefed<DOMSVGNumber> IndexedGetter(uint32_t index, bool& found,
 142                                                ErrorResult& error);
 143   already_AddRefed<DOMSVGNumber> InsertItemBefore(DOMSVGNumber& aItem,
 144                                                   uint32_t index,
 145                                                   ErrorResult& error);
 146   already_AddRefed<DOMSVGNumber> ReplaceItem(DOMSVGNumber& aItem,
 147                                              uint32_t index,
 148                                              ErrorResult& error);
 149   already_AddRefed<DOMSVGNumber> RemoveItem(uint32_t index, ErrorResult& error);
 150   already_AddRefed<DOMSVGNumber> AppendItem(DOMSVGNumber& newItem,
 151                                             ErrorResult& error) {
 152     return InsertItemBefore(newItem, LengthNoFlush(), error);
 153   }
 154   uint32_t Length() const { return NumberOfItems(); }
 155
 156  private:
 157   dom::SVGElement* Element() const { return mAList->mElement; }
 158
 159   uint8_t AttrEnum() const { return mAList->mAttrEnum; }
 160
 161   /// Used to determine if this list is the baseVal or animVal list.
 162   bool IsAnimValList() const {
 163     MOZ_ASSERT(this == mAList->mBaseVal || this == mAList->mAnimVal,
 164                "Calling IsAnimValList() too early?!");
 165     return this == mAList->mAnimVal;
 166   }
 167
 168   /**
 169    * Get a reference to this object's corresponding internal SVGNumberList.
 170    *
 171    * To simplify the code we just have this one method for obtaining both
 172    * baseVal and animVal internal lists. This means that animVal lists don't
 173    * get const protection, but our setter methods guard against changing
 174    * animVal lists.
 175    */
 176   SVGNumberList& InternalList() const;
 177
 178   /// Returns the DOMSVGNumber at aIndex, creating it if necessary.
 179   already_AddRefed<DOMSVGNumber> GetItemAt(uint32_t aIndex);
 180
 181   void MaybeInsertNullInAnimValListAt(uint32_t aIndex);
 182   void MaybeRemoveItemFromAnimValListAt(uint32_t aIndex);
 183
 184   // Weak refs to our DOMSVGNumber items. The items are friends and take care
 185   // of clearing our pointer to them when they die.
 186   FallibleTArray<DOMSVGNumber*> mItems;
 187
 188   RefPtr<DOMSVGAnimatedNumberList> mAList;
 189 };
 190
 191 }  // namespace dom
 192 }  // namespace mozilla
 193
 194 #endif  // DOM_SVG_DOMSVGNUMBERLIST_H_