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