dom/svg/DOMSVGLengthList.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "nsSVGElement.h"
   7 #include "DOMSVGLengthList.h"
   8 #include "DOMSVGLength.h"
   9 #include "nsError.h"
  10 #include "SVGAnimatedLengthList.h"
  11 #include "nsCOMPtr.h"
  12 #include "mozilla/dom/SVGLengthListBinding.h"
  13 #include <algorithm>
  14
  15 // See the comment in this file's header.
  16
  17 // local helper functions
  18 namespace {
  19
  20 using mozilla::DOMSVGLength;
  21
  22 void UpdateListIndicesFromIndex(FallibleTArray<DOMSVGLength*>& aItemsArray,
  23                                 uint32_t aStartingIndex)
  24 {
  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 {
  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_SCRIPT_OBJECTS
  58 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
  59 NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(DOMSVGLengthList)
  60   NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER
  61 NS_IMPL_CYCLE_COLLECTION_TRACE_END
  62
  63 NS_IMPL_CYCLE_COLLECTING_ADDREF(DOMSVGLengthList)
  64 NS_IMPL_CYCLE_COLLECTING_RELEASE(DOMSVGLengthList)
  65
  66 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DOMSVGLengthList)
  67   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
  68   NS_INTERFACE_MAP_ENTRY(nsISupports)
  69 NS_INTERFACE_MAP_END
  70
  71 JSObject*
  72 DOMSVGLengthList::WrapObject(JSContext *cx)
  73 {
  74   return mozilla::dom::SVGLengthListBinding::Wrap(cx, this);
  75 }
  76
  77 //----------------------------------------------------------------------
  78 // Helper class: AutoChangeLengthListNotifier
  79 // Stack-based helper class to pair calls to WillChangeLengthList and
  80 // DidChangeLengthList.
  81 class MOZ_STACK_CLASS AutoChangeLengthListNotifier
  82 {
  83 public:
  84   explicit AutoChangeLengthListNotifier(DOMSVGLengthList* aLengthList MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
  85     : mLengthList(aLengthList)
  86   {
  87     MOZ_GUARD_OBJECT_NOTIFIER_INIT;
  88     MOZ_ASSERT(mLengthList, "Expecting non-null lengthList");
  89     mEmptyOrOldValue =
  90       mLengthList->Element()->WillChangeLengthList(mLengthList->AttrEnum());
  91   }
  92
  93   ~AutoChangeLengthListNotifier()
  94   {
  95     mLengthList->Element()->DidChangeLengthList(mLengthList->AttrEnum(),
  96                                                 mEmptyOrOldValue);
  97     if (mLengthList->IsAnimating()) {
  98       mLengthList->Element()->AnimationNeedsResample();
  99     }
 100   }
 101
 102 private:
 103   DOMSVGLengthList* const mLengthList;
 104   nsAttrValue       mEmptyOrOldValue;
 105   MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
 106 };
 107
 108 void
 109 DOMSVGLengthList::InternalListLengthWillChange(uint32_t aNewLength)
 110 {
 111   uint32_t oldLength = mItems.Length();
 112
 113   if (aNewLength > DOMSVGLength::MaxListIndex()) {
 114     // It's safe to get out of sync with our internal list as long as we have
 115     // FEWER items than it does.
 116     aNewLength = DOMSVGLength::MaxListIndex();
 117   }
 118
 119   nsRefPtr<DOMSVGLengthList> kungFuDeathGrip;
 120   if (aNewLength < oldLength) {
 121     // RemovingFromList() might clear last reference to |this|.
 122     // Retain a temporary reference to keep from dying before returning.
 123     kungFuDeathGrip = this;
 124   }
 125
 126   // If our length will decrease, notify the items that will be removed:
 127   for (uint32_t i = aNewLength; i < oldLength; ++i) {
 128     if (mItems[i]) {
 129       mItems[i]->RemovingFromList();
 130     }
 131   }
 132
 133   if (!mItems.SetLength(aNewLength)) {
 134     // We silently ignore SetLength OOM failure since being out of sync is safe
 135     // so long as we have *fewer* items than our internal list.
 136     mItems.Clear();
 137     return;
 138   }
 139
 140   // If our length has increased, null out the new pointers:
 141   for (uint32_t i = oldLength; i < aNewLength; ++i) {
 142     mItems[i] = nullptr;
 143   }
 144 }
 145
 146 SVGLengthList&
 147 DOMSVGLengthList::InternalList() const
 148 {
 149   SVGAnimatedLengthList *alist = Element()->GetAnimatedLengthList(AttrEnum());
 150   return IsAnimValList() && alist->mAnimVal ? *alist->mAnimVal : alist->mBaseVal;
 151 }
 152
 153 // ----------------------------------------------------------------------------
 154
 155 void
 156 DOMSVGLengthList::Clear(ErrorResult& aError)
 157 {
 158   if (IsAnimValList()) {
 159     aError.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);
 160     return;
 161   }
 162
 163   if (LengthNoFlush() > 0) {
 164     AutoChangeLengthListNotifier notifier(this);
 165     // Notify any existing DOM items of removal *before* truncating the lists
 166     // so that they can find their SVGLength internal counterparts and copy
 167     // their values. This also notifies the animVal list:
 168     mAList->InternalBaseValListWillChangeTo(SVGLengthList());
 169
 170     mItems.Clear();
 171     InternalList().Clear();
 172   }
 173 }
 174
 175 already_AddRefed<DOMSVGLength>
 176 DOMSVGLengthList::Initialize(DOMSVGLength& newItem,
 177                              ErrorResult& error)
 178 {
 179   if (IsAnimValList()) {
 180     error.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);
 181     return nullptr;
 182   }
 183
 184   // If newItem already has an owner or is reflecting an attribute, we should
 185   // insert a clone of newItem, and for consistency, this should happen even if
 186   // *this* is the list that newItem is currently in. Note that in the case of
 187   // newItem being in this list, the Clear() call before the InsertItemBefore()
 188   // call would remove it from this list, and so the InsertItemBefore() call
 189   // would not insert a clone of newItem, it would actually insert newItem. To
 190   // prevent that from happening we have to do the clone here, if necessary.
 191
 192   nsRefPtr<DOMSVGLength> domItem = &newItem;
 193   if (!domItem) {
 194     error.Throw(NS_ERROR_DOM_SVG_WRONG_TYPE_ERR);
 195     return nullptr;
 196   }
 197   if (domItem->HasOwner() || domItem->IsReflectingAttribute()) {
 198     domItem = domItem->Copy();
 199   }
 200
 201   ErrorResult rv;
 202   Clear(rv);
 203   MOZ_ASSERT(!rv.Failed());
 204   return InsertItemBefore(*domItem, 0, error);
 205 }
 206
 207 already_AddRefed<DOMSVGLength>
 208 DOMSVGLengthList::GetItem(uint32_t index, ErrorResult& error)
 209 {
 210   bool found;
 211   nsRefPtr<DOMSVGLength> item = IndexedGetter(index, found, error);
 212   if (!found) {
 213     error.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
 214   }
 215   return item.forget();
 216 }
 217
 218 already_AddRefed<DOMSVGLength>
 219 DOMSVGLengthList::IndexedGetter(uint32_t index, bool& found, ErrorResult& error)
 220 {
 221   if (IsAnimValList()) {
 222     Element()->FlushAnimations();
 223   }
 224   found = index < LengthNoFlush();
 225   if (found) {
 226     return GetItemAt(index);
 227   }
 228   return nullptr;
 229 }
 230
 231 already_AddRefed<DOMSVGLength>
 232 DOMSVGLengthList::InsertItemBefore(DOMSVGLength& newItem,
 233                                    uint32_t index,
 234                                    ErrorResult& error)
 235 {
 236   if (IsAnimValList()) {
 237     error.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);
 238     return nullptr;
 239   }
 240
 241   index = std::min(index, LengthNoFlush());
 242   if (index >= DOMSVGLength::MaxListIndex()) {
 243     error.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
 244     return nullptr;
 245   }
 246
 247   nsRefPtr<DOMSVGLength> domItem = &newItem;
 248   if (!domItem) {
 249     error.Throw(NS_ERROR_DOM_SVG_WRONG_TYPE_ERR);
 250     return nullptr;
 251   }
 252   if (domItem->HasOwner() || domItem->IsReflectingAttribute()) {
 253     domItem = domItem->Copy(); // must do this before changing anything!
 254   }
 255
 256   // Ensure we have enough memory so we can avoid complex error handling below:
 257   if (!mItems.SetCapacity(mItems.Length() + 1) ||
 258       !InternalList().SetCapacity(InternalList().Length() + 1)) {
 259     error.Throw(NS_ERROR_OUT_OF_MEMORY);
 260     return nullptr;
 261   }
 262
 263   AutoChangeLengthListNotifier notifier(this);
 264   // Now that we know we're inserting, keep animVal list in sync as necessary.
 265   MaybeInsertNullInAnimValListAt(index);
 266
 267   InternalList().InsertItem(index, domItem->ToSVGLength());
 268   mItems.InsertElementAt(index, domItem.get());
 269
 270   // This MUST come after the insertion into InternalList(), or else under the
 271   // insertion into InternalList() the values read from domItem would be bad
 272   // data from InternalList() itself!:
 273   domItem->InsertingIntoList(this, AttrEnum(), index, IsAnimValList());
 274
 275   UpdateListIndicesFromIndex(mItems, index + 1);
 276
 277   return domItem.forget();
 278 }
 279
 280 already_AddRefed<DOMSVGLength>
 281 DOMSVGLengthList::ReplaceItem(DOMSVGLength& newItem,
 282                               uint32_t index,
 283                               ErrorResult& error)
 284 {
 285   if (IsAnimValList()) {
 286     error.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);
 287     return nullptr;
 288   }
 289
 290   nsRefPtr<DOMSVGLength> domItem = &newItem;
 291   if (!domItem) {
 292     error.Throw(NS_ERROR_DOM_SVG_WRONG_TYPE_ERR);
 293     return nullptr;
 294   }
 295   if (index >= LengthNoFlush()) {
 296     error.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
 297     return nullptr;
 298   }
 299   if (domItem->HasOwner() || domItem->IsReflectingAttribute()) {
 300     domItem = domItem->Copy(); // must do this before changing anything!
 301   }
 302
 303   AutoChangeLengthListNotifier notifier(this);
 304   if (mItems[index]) {
 305     // Notify any existing DOM item of removal *before* modifying the lists so
 306     // that the DOM item can copy the *old* value at its index:
 307     mItems[index]->RemovingFromList();
 308   }
 309
 310   InternalList()[index] = domItem->ToSVGLength();
 311   mItems[index] = domItem;
 312
 313   // This MUST come after the ToSVGPoint() call, otherwise that call
 314   // would end up reading bad data from InternalList()!
 315   domItem->InsertingIntoList(this, AttrEnum(), index, IsAnimValList());
 316
 317   return domItem.forget();
 318 }
 319
 320 already_AddRefed<DOMSVGLength>
 321 DOMSVGLengthList::RemoveItem(uint32_t index,
 322                              ErrorResult& error)
 323 {
 324   if (IsAnimValList()) {
 325     error.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);
 326     return nullptr;
 327   }
 328
 329   if (index >= LengthNoFlush()) {
 330     error.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
 331     return nullptr;
 332   }
 333
 334   AutoChangeLengthListNotifier notifier(this);
 335   // Now that we know we're removing, keep animVal list in sync as necessary.
 336   // Do this *before* touching InternalList() so the removed item can get its
 337   // internal value.
 338   MaybeRemoveItemFromAnimValListAt(index);
 339
 340   // We have to return the removed item, so get it, creating it if necessary:
 341   nsCOMPtr<DOMSVGLength> result = GetItemAt(index);
 342
 343   // Notify the DOM item of removal *before* modifying the lists so that the
 344   // DOM item can copy its *old* value:
 345   mItems[index]->RemovingFromList();
 346
 347   InternalList().RemoveItem(index);
 348   mItems.RemoveElementAt(index);
 349
 350   UpdateListIndicesFromIndex(mItems, index);
 351
 352   return result.forget();
 353 }
 354
 355 already_AddRefed<DOMSVGLength>
 356 DOMSVGLengthList::GetItemAt(uint32_t aIndex)
 357 {
 358   MOZ_ASSERT(aIndex < mItems.Length());
 359
 360   if (!mItems[aIndex]) {
 361     mItems[aIndex] = new DOMSVGLength(this, AttrEnum(), aIndex, IsAnimValList());
 362   }
 363   nsRefPtr<DOMSVGLength> result = mItems[aIndex];
 364   return result.forget();
 365 }
 366
 367 void
 368 DOMSVGLengthList::MaybeInsertNullInAnimValListAt(uint32_t aIndex)
 369 {
 370   NS_ABORT_IF_FALSE(!IsAnimValList(), "call from baseVal to animVal");
 371
 372   DOMSVGLengthList* animVal = mAList->mAnimVal;
 373
 374   if (!animVal || mAList->IsAnimating()) {
 375     // No animVal list wrapper, or animVal not a clone of baseVal
 376     return;
 377   }
 378
 379   NS_ABORT_IF_FALSE(animVal->mItems.Length() == mItems.Length(),
 380                     "animVal list not in sync!");
 381
 382   animVal->mItems.InsertElementAt(aIndex, static_cast<DOMSVGLength*>(nullptr));
 383
 384   UpdateListIndicesFromIndex(animVal->mItems, aIndex + 1);
 385 }
 386
 387 void
 388 DOMSVGLengthList::MaybeRemoveItemFromAnimValListAt(uint32_t aIndex)
 389 {
 390   NS_ABORT_IF_FALSE(!IsAnimValList(), "call from baseVal to animVal");
 391
 392   // This needs to be a strong reference; otherwise, the RemovingFromList call
 393   // below might drop the last reference to animVal before we're done with it.
 394   nsRefPtr<DOMSVGLengthList> animVal = mAList->mAnimVal;
 395
 396   if (!animVal || mAList->IsAnimating()) {
 397     // No animVal list wrapper, or animVal not a clone of baseVal
 398     return;
 399   }
 400
 401   NS_ABORT_IF_FALSE(animVal->mItems.Length() == mItems.Length(),
 402                     "animVal list not in sync!");
 403
 404   if (animVal->mItems[aIndex]) {
 405     animVal->mItems[aIndex]->RemovingFromList();
 406   }
 407   animVal->mItems.RemoveElementAt(aIndex);
 408
 409   UpdateListIndicesFromIndex(animVal->mItems, aIndex);
 410 }
 411
 412 } // namespace mozilla