dom/svg/DOMSVGNumberList.cpp

   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 #include "DOMSVGNumberList.h"
   8
   9 #include "SVGElement.h"
  10 #include "DOMSVGNumber.h"
  11 #include "mozAutoDocUpdate.h"
  12 #include "nsError.h"
  13 #include "SVGAnimatedNumberList.h"
  14 #include "mozilla/dom/SVGNumberListBinding.h"
  15 #include "mozilla/RefPtr.h"
  16 #include <algorithm>
  17
  18 // See the comment in this file's header.
  19
  20 // local helper functions
  21 namespace {
  22
  23 using mozilla::dom::DOMSVGNumber;
  24
  25 void UpdateListIndicesFromIndex(FallibleTArray<DOMSVGNumber*>& aItemsArray,
  26                                 uint32_t aStartingIndex) {
  27   uint32_t length = aItemsArray.Length();
  28
  29   for (uint32_t i = aStartingIndex; i < length; ++i) {
  30     if (aItemsArray[i]) {
  31       aItemsArray[i]->UpdateListIndex(i);
  32     }
  33   }
  34 }
  35
  36 }  // namespace
  37
  38 namespace mozilla {
  39 namespace dom {
  40
  41 // We could use NS_IMPL_CYCLE_COLLECTION(, except that in Unlink() we need to
  42 // clear our DOMSVGAnimatedNumberList's weak ref to us to be safe. (The other
  43 // option would be to not unlink and rely on the breaking of the other edges in
  44 // the cycle, as NS_SVG_VAL_IMPL_CYCLE_COLLECTION does.)
  45 NS_IMPL_CYCLE_COLLECTION_CLASS(DOMSVGNumberList)
  46
  47 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(DOMSVGNumberList)
  48   if (tmp->mAList) {
  49     if (tmp->IsAnimValList()) {
  50       tmp->mAList->mAnimVal = nullptr;
  51     } else {
  52       tmp->mAList->mBaseVal = nullptr;
  53     }
  54     NS_IMPL_CYCLE_COLLECTION_UNLINK(mAList)
  55   }
  56   NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
  57 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
  58 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(DOMSVGNumberList)
  59   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAList)
  60 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
  61 NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(DOMSVGNumberList)
  62   NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER
  63 NS_IMPL_CYCLE_COLLECTION_TRACE_END
  64
  65 NS_IMPL_CYCLE_COLLECTING_ADDREF(DOMSVGNumberList)
  66 NS_IMPL_CYCLE_COLLECTING_RELEASE(DOMSVGNumberList)
  67
  68 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DOMSVGNumberList)
  69   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
  70   NS_INTERFACE_MAP_ENTRY(nsISupports)
  71 NS_INTERFACE_MAP_END
  72
  73 JSObject* DOMSVGNumberList::WrapObject(JSContext* cx,
  74                                        JS::Handle<JSObject*> aGivenProto) {
  75   return mozilla::dom::SVGNumberList_Binding::Wrap(cx, this, aGivenProto);
  76 }
  77
  78 //----------------------------------------------------------------------
  79 // Helper class: AutoChangeNumberListNotifier
  80 // Stack-based helper class to pair calls to WillChangeNumberList and
  81 // DidChangeNumberList.
  82 class MOZ_RAII AutoChangeNumberListNotifier : public mozAutoDocUpdate {
  83  public:
  84   explicit AutoChangeNumberListNotifier(
  85       DOMSVGNumberList* aNumberList MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
  86       : mozAutoDocUpdate(aNumberList->Element()->GetComposedDoc(), true),
  87         mNumberList(aNumberList) {
  88     MOZ_GUARD_OBJECT_NOTIFIER_INIT;
  89     MOZ_ASSERT(mNumberList, "Expecting non-null numberList");
  90     mEmptyOrOldValue = mNumberList->Element()->WillChangeNumberList(
  91         mNumberList->AttrEnum(), *this);
  92   }
  93
  94   ~AutoChangeNumberListNotifier() {
  95     mNumberList->Element()->DidChangeNumberList(mNumberList->AttrEnum(),
  96                                                 mEmptyOrOldValue, *this);
  97     if (mNumberList->IsAnimating()) {
  98       mNumberList->Element()->AnimationNeedsResample();
  99     }
 100   }
 101
 102  private:
 103   DOMSVGNumberList* const mNumberList;
 104   nsAttrValue mEmptyOrOldValue;
 105   MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
 106 };
 107
 108 void DOMSVGNumberList::InternalListLengthWillChange(uint32_t aNewLength) {
 109   uint32_t oldLength = mItems.Length();
 110
 111   if (aNewLength > DOMSVGNumber::MaxListIndex()) {
 112     // It's safe to get out of sync with our internal list as long as we have
 113     // FEWER items than it does.
 114     aNewLength = DOMSVGNumber::MaxListIndex();
 115   }
 116
 117   RefPtr<DOMSVGNumberList> kungFuDeathGrip;
 118   if (aNewLength < oldLength) {
 119     // RemovingFromList() might clear last reference to |this|.
 120     // Retain a temporary reference to keep from dying before returning.
 121     kungFuDeathGrip = this;
 122   }
 123
 124   // If our length will decrease, notify the items that will be removed:
 125   for (uint32_t i = aNewLength; i < oldLength; ++i) {
 126     if (mItems[i]) {
 127       mItems[i]->RemovingFromList();
 128     }
 129   }
 130
 131   if (!mItems.SetLength(aNewLength, fallible)) {
 132     // We silently ignore SetLength OOM failure since being out of sync is safe
 133     // so long as we have *fewer* items than our internal list.
 134     mItems.Clear();
 135     return;
 136   }
 137
 138   // If our length has increased, null out the new pointers:
 139   for (uint32_t i = oldLength; i < aNewLength; ++i) {
 140     mItems[i] = nullptr;
 141   }
 142 }
 143
 144 SVGNumberList& DOMSVGNumberList::InternalList() const {
 145   SVGAnimatedNumberList* alist = Element()->GetAnimatedNumberList(AttrEnum());
 146   return IsAnimValList() && alist->mAnimVal ? *alist->mAnimVal
 147                                             : alist->mBaseVal;
 148 }
 149
 150 void DOMSVGNumberList::Clear(ErrorResult& error) {
 151   if (IsAnimValList()) {
 152     error.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);
 153     return;
 154   }
 155
 156   if (LengthNoFlush() > 0) {
 157     AutoChangeNumberListNotifier notifier(this);
 158     // Notify any existing DOM items of removal *before* truncating the lists
 159     // so that they can find their SVGNumber internal counterparts and copy
 160     // their values. This also notifies the animVal list:
 161     mAList->InternalBaseValListWillChangeTo(SVGNumberList());
 162
 163     mItems.Clear();
 164     InternalList().Clear();
 165   }
 166 }
 167
 168 already_AddRefed<DOMSVGNumber> DOMSVGNumberList::Initialize(
 169     DOMSVGNumber& aItem, ErrorResult& error) {
 170   if (IsAnimValList()) {
 171     error.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);
 172     return nullptr;
 173   }
 174
 175   // If newItem is already in a list we should insert a clone of newItem, and
 176   // for consistency, this should happen even if *this* is the list that
 177   // newItem is currently in. Note that in the case of newItem being in this
 178   // list, the Clear() call before the InsertItemBefore() call would remove it
 179   // from this list, and so the InsertItemBefore() call would not insert a
 180   // clone of newItem, it would actually insert newItem. To prevent that from
 181   // happening we have to do the clone here, if necessary.
 182   RefPtr<DOMSVGNumber> domItem = aItem.HasOwner() ? aItem.Clone() : &aItem;
 183
 184   Clear(error);
 185   MOZ_ASSERT(!error.Failed());
 186   return InsertItemBefore(*domItem, 0, error);
 187 }
 188
 189 already_AddRefed<DOMSVGNumber> DOMSVGNumberList::GetItem(uint32_t index,
 190                                                          ErrorResult& error) {
 191   bool found;
 192   RefPtr<DOMSVGNumber> item = IndexedGetter(index, found, error);
 193   if (!found) {
 194     error.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
 195   }
 196   return item.forget();
 197 }
 198
 199 already_AddRefed<DOMSVGNumber> DOMSVGNumberList::IndexedGetter(
 200     uint32_t index, bool& found, ErrorResult& error) {
 201   if (IsAnimValList()) {
 202     Element()->FlushAnimations();
 203   }
 204   found = index < LengthNoFlush();
 205   if (found) {
 206     return GetItemAt(index);
 207   }
 208   return nullptr;
 209 }
 210
 211 already_AddRefed<DOMSVGNumber> DOMSVGNumberList::InsertItemBefore(
 212     DOMSVGNumber& aItem, uint32_t index, ErrorResult& error) {
 213   if (IsAnimValList()) {
 214     error.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);
 215     return nullptr;
 216   }
 217
 218   index = std::min(index, LengthNoFlush());
 219   if (index >= DOMSVGNumber::MaxListIndex()) {
 220     error.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
 221     return nullptr;
 222   }
 223
 224   // must do this before changing anything!
 225   RefPtr<DOMSVGNumber> domItem = aItem.HasOwner() ? aItem.Clone() : &aItem;
 226
 227   // Ensure we have enough memory so we can avoid complex error handling below:
 228   if (!mItems.SetCapacity(mItems.Length() + 1, fallible) ||
 229       !InternalList().SetCapacity(InternalList().Length() + 1)) {
 230     error.Throw(NS_ERROR_OUT_OF_MEMORY);
 231     return nullptr;
 232   }
 233   if (AnimListMirrorsBaseList()) {
 234     if (!mAList->mAnimVal->mItems.SetCapacity(
 235             mAList->mAnimVal->mItems.Length() + 1, fallible)) {
 236       error.Throw(NS_ERROR_OUT_OF_MEMORY);
 237       return nullptr;
 238     }
 239   }
 240
 241   AutoChangeNumberListNotifier notifier(this);
 242   // Now that we know we're inserting, keep animVal list in sync as necessary.
 243   MaybeInsertNullInAnimValListAt(index);
 244
 245   InternalList().InsertItem(index, domItem->ToSVGNumber());
 246   MOZ_ALWAYS_TRUE(mItems.InsertElementAt(index, domItem, fallible));
 247
 248   // This MUST come after the insertion into InternalList(), or else under the
 249   // insertion into InternalList() the values read from domItem would be bad
 250   // data from InternalList() itself!:
 251   domItem->InsertingIntoList(this, AttrEnum(), index, IsAnimValList());
 252
 253   UpdateListIndicesFromIndex(mItems, index + 1);
 254
 255   return domItem.forget();
 256 }
 257
 258 already_AddRefed<DOMSVGNumber> DOMSVGNumberList::ReplaceItem(
 259     DOMSVGNumber& aItem, uint32_t index, ErrorResult& error) {
 260   if (IsAnimValList()) {
 261     error.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);
 262     return nullptr;
 263   }
 264
 265   if (index >= LengthNoFlush()) {
 266     error.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
 267     return nullptr;
 268   }
 269
 270   // must do this before changing anything!
 271   RefPtr<DOMSVGNumber> domItem = aItem.HasOwner() ? aItem.Clone() : &aItem;
 272
 273   AutoChangeNumberListNotifier notifier(this);
 274   if (mItems[index]) {
 275     // Notify any existing DOM item of removal *before* modifying the lists so
 276     // that the DOM item can copy the *old* value at its index:
 277     mItems[index]->RemovingFromList();
 278   }
 279
 280   InternalList()[index] = domItem->ToSVGNumber();
 281   mItems[index] = domItem;
 282
 283   // This MUST come after the ToSVGPoint() call, otherwise that call
 284   // would end up reading bad data from InternalList()!
 285   domItem->InsertingIntoList(this, AttrEnum(), index, IsAnimValList());
 286
 287   return domItem.forget();
 288 }
 289
 290 already_AddRefed<DOMSVGNumber> DOMSVGNumberList::RemoveItem(
 291     uint32_t index, ErrorResult& error) {
 292   if (IsAnimValList()) {
 293     error.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);
 294     return nullptr;
 295   }
 296
 297   if (index >= LengthNoFlush()) {
 298     error.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
 299     return nullptr;
 300   }
 301
 302   // Now that we know we're removing, keep animVal list in sync as necessary.
 303   // Do this *before* touching InternalList() so the removed item can get its
 304   // internal value.
 305   MaybeRemoveItemFromAnimValListAt(index);
 306
 307   // We have to return the removed item, so get it, creating it if necessary:
 308   RefPtr<DOMSVGNumber> result = GetItemAt(index);
 309
 310   AutoChangeNumberListNotifier notifier(this);
 311   // Notify the DOM item of removal *before* modifying the lists so that the
 312   // DOM item can copy its *old* value:
 313   mItems[index]->RemovingFromList();
 314
 315   InternalList().RemoveItem(index);
 316   mItems.RemoveElementAt(index);
 317
 318   UpdateListIndicesFromIndex(mItems, index);
 319
 320   return result.forget();
 321 }
 322
 323 already_AddRefed<DOMSVGNumber> DOMSVGNumberList::GetItemAt(uint32_t aIndex) {
 324   MOZ_ASSERT(aIndex < mItems.Length());
 325
 326   if (!mItems[aIndex]) {
 327     mItems[aIndex] =
 328         new DOMSVGNumber(this, AttrEnum(), aIndex, IsAnimValList());
 329   }
 330   RefPtr<DOMSVGNumber> result = mItems[aIndex];
 331   return result.forget();
 332 }
 333
 334 void DOMSVGNumberList::MaybeInsertNullInAnimValListAt(uint32_t aIndex) {
 335   MOZ_ASSERT(!IsAnimValList(), "call from baseVal to animVal");
 336
 337   if (!AnimListMirrorsBaseList()) {
 338     return;
 339   }
 340
 341   DOMSVGNumberList* animVal = mAList->mAnimVal;
 342
 343   MOZ_ASSERT(animVal, "AnimListMirrorsBaseList() promised a non-null animVal");
 344   MOZ_ASSERT(animVal->mItems.Length() == mItems.Length(),
 345              "animVal list not in sync!");
 346   MOZ_ALWAYS_TRUE(animVal->mItems.InsertElementAt(aIndex, nullptr, fallible));
 347
 348   UpdateListIndicesFromIndex(animVal->mItems, aIndex + 1);
 349 }
 350
 351 void DOMSVGNumberList::MaybeRemoveItemFromAnimValListAt(uint32_t aIndex) {
 352   MOZ_ASSERT(!IsAnimValList(), "call from baseVal to animVal");
 353
 354   if (!AnimListMirrorsBaseList()) {
 355     return;
 356   }
 357
 358   // This needs to be a strong reference; otherwise, the RemovingFromList call
 359   // below might drop the last reference to animVal before we're done with it.
 360   RefPtr<DOMSVGNumberList> animVal = mAList->mAnimVal;
 361
 362   MOZ_ASSERT(animVal, "AnimListMirrorsBaseList() promised a non-null animVal");
 363   MOZ_ASSERT(animVal->mItems.Length() == mItems.Length(),
 364              "animVal list not in sync!");
 365
 366   if (animVal->mItems[aIndex]) {
 367     animVal->mItems[aIndex]->RemovingFromList();
 368   }
 369   animVal->mItems.RemoveElementAt(aIndex);
 370
 371   UpdateListIndicesFromIndex(animVal->mItems, aIndex);
 372 }
 373
 374 }  // namespace dom
 375 }  // namespace mozilla