dom/base/nsDOMAttributeMap.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 /*
   8  * Implementation of the |attributes| property of DOM Core's Element object.
   9  */
  10
  11 #include "nsDOMAttributeMap.h"
  12
  13 #include "mozilla/MemoryReporting.h"
  14 #include "mozilla/dom/Attr.h"
  15 #include "mozilla/dom/Element.h"
  16 #include "mozilla/dom/NamedNodeMapBinding.h"
  17 #include "mozilla/dom/NodeInfoInlines.h"
  18 #include "nsAttrName.h"
  19 #include "nsContentUtils.h"
  20 #include "nsError.h"
  21 #include "nsIContentInlines.h"
  22 #include "nsIDocument.h"
  23 #include "nsNameSpaceManager.h"
  24 #include "nsNodeInfoManager.h"
  25 #include "nsUnicharUtils.h"
  26 #include "nsWrapperCacheInlines.h"
  27
  28 using namespace mozilla;
  29 using namespace mozilla::dom;
  30
  31 //----------------------------------------------------------------------
  32
  33 nsDOMAttributeMap::nsDOMAttributeMap(Element* aContent)
  34   : mContent(aContent)
  35 {
  36   // We don't add a reference to our content. If it goes away,
  37   // we'll be told to drop our reference
  38 }
  39
  40 /**
  41  * Clear map pointer for attributes.
  42  */
  43 PLDHashOperator
  44 RemoveMapRef(nsAttrHashKey::KeyType aKey, nsRefPtr<Attr>& aData,
  45              void* aUserArg)
  46 {
  47   aData->SetMap(nullptr);
  48
  49   return PL_DHASH_REMOVE;
  50 }
  51
  52 nsDOMAttributeMap::~nsDOMAttributeMap()
  53 {
  54   if (mAttributeCache) {
  55     mAttributeCache->Enumerate(RemoveMapRef, nullptr);
  56   }
  57 }
  58
  59 void
  60 nsDOMAttributeMap::DropReference()
  61 {
  62   if (mAttributeCache) {
  63     mAttributeCache->Enumerate(RemoveMapRef, nullptr);
  64   }
  65   mContent = nullptr;
  66 }
  67
  68 NS_IMPL_CYCLE_COLLECTION_CLASS(nsDOMAttributeMap)
  69
  70 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsDOMAttributeMap)
  71   tmp->DropReference();
  72   NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
  73   NS_IMPL_CYCLE_COLLECTION_UNLINK(mContent)
  74 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
  75
  76
  77 PLDHashOperator
  78 TraverseMapEntry(nsAttrHashKey::KeyType aKey, nsRefPtr<Attr>& aData,
  79                  void* aUserArg)
  80 {
  81   nsCycleCollectionTraversalCallback *cb =
  82     static_cast<nsCycleCollectionTraversalCallback*>(aUserArg);
  83
  84   cb->NoteXPCOMChild(static_cast<nsINode*>(aData.get()));
  85
  86   return PL_DHASH_NEXT;
  87 }
  88
  89 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsDOMAttributeMap)
  90   if (tmp->mAttributeCache) {
  91     tmp->mAttributeCache->Enumerate(TraverseMapEntry, &cb);
  92   }
  93   NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS
  94   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mContent)
  95 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
  96
  97 NS_IMPL_CYCLE_COLLECTION_TRACE_WRAPPERCACHE(nsDOMAttributeMap)
  98
  99 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_BEGIN(nsDOMAttributeMap)
 100   if (tmp->IsBlack()) {
 101     if (tmp->mContent) {
 102       // The map owns the element so we can mark it when the
 103       // map itself is certainly alive.
 104       mozilla::dom::FragmentOrElement::MarkNodeChildren(tmp->mContent);
 105     }
 106     return true;
 107   }
 108   if (tmp->mContent &&
 109       mozilla::dom::FragmentOrElement::CanSkip(tmp->mContent, true)) {
 110     return true;
 111   }
 112 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_END
 113
 114 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_BEGIN(nsDOMAttributeMap)
 115   return tmp->IsBlackAndDoesNotNeedTracing(tmp);
 116 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_END
 117
 118 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_BEGIN(nsDOMAttributeMap)
 119   return tmp->IsBlack();
 120 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_END
 121
 122 // QueryInterface implementation for nsDOMAttributeMap
 123 NS_INTERFACE_TABLE_HEAD(nsDOMAttributeMap)
 124   NS_INTERFACE_TABLE(nsDOMAttributeMap, nsIDOMMozNamedAttrMap)
 125   NS_INTERFACE_TABLE_TO_MAP_SEGUE
 126   NS_WRAPPERCACHE_INTERFACE_TABLE_ENTRY
 127   NS_INTERFACE_MAP_ENTRIES_CYCLE_COLLECTION(nsDOMAttributeMap)
 128 NS_INTERFACE_MAP_END
 129
 130 NS_IMPL_CYCLE_COLLECTING_ADDREF(nsDOMAttributeMap)
 131 NS_IMPL_CYCLE_COLLECTING_RELEASE(nsDOMAttributeMap)
 132
 133 PLDHashOperator
 134 SetOwnerDocumentFunc(nsAttrHashKey::KeyType aKey,
 135                      nsRefPtr<Attr>& aData,
 136                      void* aUserArg)
 137 {
 138   nsresult rv = aData->SetOwnerDocument(static_cast<nsIDocument*>(aUserArg));
 139
 140   return NS_FAILED(rv) ? PL_DHASH_STOP : PL_DHASH_NEXT;
 141 }
 142
 143 nsresult
 144 nsDOMAttributeMap::SetOwnerDocument(nsIDocument* aDocument)
 145 {
 146   if (mAttributeCache) {
 147     uint32_t n = mAttributeCache->Enumerate(SetOwnerDocumentFunc, aDocument);
 148     NS_ENSURE_TRUE(n == mAttributeCache->Count(), NS_ERROR_FAILURE);
 149   }
 150   return NS_OK;
 151 }
 152
 153 void
 154 nsDOMAttributeMap::DropAttribute(int32_t aNamespaceID, nsIAtom* aLocalName)
 155 {
 156   nsAttrKey attr(aNamespaceID, aLocalName);
 157   if (mAttributeCache) {
 158     Attr *node = mAttributeCache->GetWeak(attr);
 159     if (node) {
 160       // Break link to map
 161       node->SetMap(nullptr);
 162
 163       // Remove from cache
 164       mAttributeCache->Remove(attr);
 165     }
 166   }
 167 }
 168
 169 already_AddRefed<Attr>
 170 nsDOMAttributeMap::RemoveAttribute(mozilla::dom::NodeInfo* aNodeInfo)
 171 {
 172   NS_ASSERTION(aNodeInfo, "RemoveAttribute() called with aNodeInfo == nullptr!");
 173
 174   nsAttrKey attr(aNodeInfo->NamespaceID(), aNodeInfo->NameAtom());
 175
 176   nsRefPtr<Attr> node;
 177   if (mAttributeCache && mAttributeCache->Get(attr, getter_AddRefs(node))) {
 178     // Break link to map
 179     node->SetMap(nullptr);
 180
 181     // Remove from cache
 182     mAttributeCache->Remove(attr);
 183   } else {
 184     nsAutoString value;
 185     // As we are removing the attribute we need to set the current value in
 186     // the attribute node.
 187     mContent->GetAttr(aNodeInfo->NamespaceID(), aNodeInfo->NameAtom(), value);
 188     nsRefPtr<mozilla::dom::NodeInfo> ni = aNodeInfo;
 189     node = new Attr(nullptr, ni.forget(), value, true);
 190   }
 191
 192   return node.forget();
 193 }
 194
 195 Attr*
 196 nsDOMAttributeMap::GetAttribute(mozilla::dom::NodeInfo* aNodeInfo, bool aNsAware)
 197 {
 198   NS_ASSERTION(aNodeInfo, "GetAttribute() called with aNodeInfo == nullptr!");
 199
 200   nsAttrKey attr(aNodeInfo->NamespaceID(), aNodeInfo->NameAtom());
 201
 202   EnsureAttributeCache();
 203   Attr* node = mAttributeCache->GetWeak(attr);
 204   if (!node) {
 205     nsRefPtr<mozilla::dom::NodeInfo> ni = aNodeInfo;
 206     nsRefPtr<Attr> newAttr =
 207       new Attr(this, ni.forget(), EmptyString(), aNsAware);
 208     mAttributeCache->Put(attr, newAttr);
 209     node = newAttr;
 210   }
 211
 212   return node;
 213 }
 214
 215 Attr*
 216 nsDOMAttributeMap::NamedGetter(const nsAString& aAttrName, bool& aFound)
 217 {
 218   aFound = false;
 219   NS_ENSURE_TRUE(mContent, nullptr);
 220
 221   nsRefPtr<mozilla::dom::NodeInfo> ni = mContent->GetExistingAttrNameFromQName(aAttrName);
 222   if (!ni) {
 223     return nullptr;
 224   }
 225
 226   aFound = true;
 227   return GetAttribute(ni, false);
 228 }
 229
 230 bool
 231 nsDOMAttributeMap::NameIsEnumerable(const nsAString& aName)
 232 {
 233   return true;
 234 }
 235
 236 Attr*
 237 nsDOMAttributeMap::GetNamedItem(const nsAString& aAttrName)
 238 {
 239   bool dummy;
 240   return NamedGetter(aAttrName, dummy);
 241 }
 242
 243 NS_IMETHODIMP
 244 nsDOMAttributeMap::GetNamedItem(const nsAString& aAttrName,
 245                                 nsIDOMAttr** aAttribute)
 246 {
 247   NS_ENSURE_ARG_POINTER(aAttribute);
 248
 249   NS_IF_ADDREF(*aAttribute = GetNamedItem(aAttrName));
 250
 251   return NS_OK;
 252 }
 253
 254 void
 255 nsDOMAttributeMap::EnsureAttributeCache()
 256 {
 257   if (!mAttributeCache) {
 258     mAttributeCache = MakeUnique<AttrCache>();
 259   }
 260 }
 261
 262 NS_IMETHODIMP
 263 nsDOMAttributeMap::SetNamedItem(nsIDOMAttr* aAttr, nsIDOMAttr** aReturn)
 264 {
 265   Attr* attribute = static_cast<Attr*>(aAttr);
 266   NS_ENSURE_ARG(attribute);
 267
 268   ErrorResult rv;
 269   *aReturn = SetNamedItem(*attribute, rv).take();
 270   return rv.ErrorCode();
 271 }
 272
 273 NS_IMETHODIMP
 274 nsDOMAttributeMap::SetNamedItemNS(nsIDOMAttr* aAttr, nsIDOMAttr** aReturn)
 275 {
 276   Attr* attribute = static_cast<Attr*>(aAttr);
 277   NS_ENSURE_ARG(attribute);
 278
 279   ErrorResult rv;
 280   *aReturn = SetNamedItemNS(*attribute, rv).take();
 281   return rv.ErrorCode();
 282 }
 283
 284 already_AddRefed<Attr>
 285 nsDOMAttributeMap::SetNamedItemInternal(Attr& aAttr,
 286                                         bool aWithNS,
 287                                         ErrorResult& aError)
 288 {
 289   NS_ENSURE_TRUE(mContent, nullptr);
 290
 291   // XXX should check same-origin between mContent and aAttr however
 292   // nsContentUtils::CheckSameOrigin can't deal with attributenodes yet
 293
 294   // Check that attribute is not owned by somebody else
 295   nsDOMAttributeMap* owner = aAttr.GetMap();
 296   if (owner) {
 297     if (owner != this) {
 298       aError.Throw(NS_ERROR_DOM_INUSE_ATTRIBUTE_ERR);
 299       return nullptr;
 300     }
 301
 302     // setting a preexisting attribute is a no-op, just return the same
 303     // node.
 304     nsRefPtr<Attr> attribute = &aAttr;
 305     return attribute.forget();
 306   }
 307
 308   nsresult rv;
 309   if (mContent->OwnerDoc() != aAttr.OwnerDoc()) {
 310     nsCOMPtr<nsINode> adoptedNode =
 311       mContent->OwnerDoc()->AdoptNode(aAttr, aError);
 312     if (aError.Failed()) {
 313       return nullptr;
 314     }
 315
 316     NS_ASSERTION(adoptedNode == &aAttr, "Uh, adopt node changed nodes?");
 317   }
 318
 319   // Get nodeinfo and preexisting attribute (if it exists)
 320   nsAutoString name;
 321   nsRefPtr<mozilla::dom::NodeInfo> ni;
 322
 323   nsRefPtr<Attr> attr;
 324   // SetNamedItemNS()
 325   if (aWithNS) {
 326     // Return existing attribute, if present
 327     ni = aAttr.NodeInfo();
 328
 329     if (mContent->HasAttr(ni->NamespaceID(), ni->NameAtom())) {
 330       attr = RemoveAttribute(ni);
 331     }
 332   } else { // SetNamedItem()
 333     aAttr.GetName(name);
 334
 335     // get node-info of old attribute
 336     ni = mContent->GetExistingAttrNameFromQName(name);
 337     if (ni) {
 338       attr = RemoveAttribute(ni);
 339     }
 340     else {
 341       if (mContent->IsInHTMLDocument() &&
 342           mContent->IsHTML()) {
 343         nsContentUtils::ASCIIToLower(name);
 344       }
 345
 346       rv = mContent->NodeInfo()->NodeInfoManager()->
 347         GetNodeInfo(name, nullptr, kNameSpaceID_None,
 348                     nsIDOMNode::ATTRIBUTE_NODE, getter_AddRefs(ni));
 349       if (NS_FAILED(rv)) {
 350         aError.Throw(rv);
 351         return nullptr;
 352       }
 353       // value is already empty
 354     }
 355   }
 356
 357   nsAutoString value;
 358   aAttr.GetValue(value);
 359
 360   // Add the new attribute to the attribute map before updating
 361   // its value in the element. @see bug 364413.
 362   nsAttrKey attrkey(ni->NamespaceID(), ni->NameAtom());
 363   EnsureAttributeCache();
 364   mAttributeCache->Put(attrkey, &aAttr);
 365   aAttr.SetMap(this);
 366
 367   rv = mContent->SetAttr(ni->NamespaceID(), ni->NameAtom(),
 368                          ni->GetPrefixAtom(), value, true);
 369   if (NS_FAILED(rv)) {
 370     aError.Throw(rv);
 371     DropAttribute(ni->NamespaceID(), ni->NameAtom());
 372   }
 373
 374   return attr.forget();
 375 }
 376
 377 NS_IMETHODIMP
 378 nsDOMAttributeMap::RemoveNamedItem(const nsAString& aName,
 379                                    nsIDOMAttr** aReturn)
 380 {
 381   NS_ENSURE_ARG_POINTER(aReturn);
 382
 383   ErrorResult rv;
 384   *aReturn = RemoveNamedItem(aName, rv).take();
 385   return rv.ErrorCode();
 386 }
 387
 388 already_AddRefed<Attr>
 389 nsDOMAttributeMap::RemoveNamedItem(const nsAString& aName, ErrorResult& aError)
 390 {
 391   if (!mContent) {
 392     aError.Throw(NS_ERROR_DOM_NOT_FOUND_ERR);
 393     return nullptr;
 394   }
 395
 396   nsRefPtr<mozilla::dom::NodeInfo> ni = mContent->GetExistingAttrNameFromQName(aName);
 397   if (!ni) {
 398     aError.Throw(NS_ERROR_DOM_NOT_FOUND_ERR);
 399     return nullptr;
 400   }
 401
 402   nsRefPtr<Attr> attribute = GetAttribute(ni, true);
 403
 404   // This removes the attribute node from the attribute map.
 405   aError = mContent->UnsetAttr(ni->NamespaceID(), ni->NameAtom(), true);
 406   return attribute.forget();
 407 }
 408
 409
 410 Attr*
 411 nsDOMAttributeMap::IndexedGetter(uint32_t aIndex, bool& aFound)
 412 {
 413   aFound = false;
 414   NS_ENSURE_TRUE(mContent, nullptr);
 415
 416   const nsAttrName* name = mContent->GetAttrNameAt(aIndex);
 417   NS_ENSURE_TRUE(name, nullptr);
 418
 419   aFound = true;
 420   // Don't use the nodeinfo even if one exists since it can have the wrong
 421   // owner document.
 422   nsRefPtr<mozilla::dom::NodeInfo> ni = mContent->NodeInfo()->NodeInfoManager()->
 423     GetNodeInfo(name->LocalName(), name->GetPrefix(), name->NamespaceID(),
 424                 nsIDOMNode::ATTRIBUTE_NODE);
 425   return GetAttribute(ni, true);
 426 }
 427
 428 Attr*
 429 nsDOMAttributeMap::Item(uint32_t aIndex)
 430 {
 431   bool dummy;
 432   return IndexedGetter(aIndex, dummy);
 433 }
 434
 435 NS_IMETHODIMP
 436 nsDOMAttributeMap::Item(uint32_t aIndex, nsIDOMAttr** aReturn)
 437 {
 438   NS_IF_ADDREF(*aReturn = Item(aIndex));
 439   return NS_OK;
 440 }
 441
 442 uint32_t
 443 nsDOMAttributeMap::Length() const
 444 {
 445   NS_ENSURE_TRUE(mContent, 0);
 446
 447   return mContent->GetAttrCount();
 448 }
 449
 450 nsresult
 451 nsDOMAttributeMap::GetLength(uint32_t *aLength)
 452 {
 453   NS_ENSURE_ARG_POINTER(aLength);
 454   *aLength = Length();
 455   return NS_OK;
 456 }
 457
 458 NS_IMETHODIMP
 459 nsDOMAttributeMap::GetNamedItemNS(const nsAString& aNamespaceURI,
 460                                   const nsAString& aLocalName,
 461                                   nsIDOMAttr** aReturn)
 462 {
 463   NS_IF_ADDREF(*aReturn = GetNamedItemNS(aNamespaceURI, aLocalName));
 464   return NS_OK;
 465 }
 466
 467 Attr*
 468 nsDOMAttributeMap::GetNamedItemNS(const nsAString& aNamespaceURI,
 469                                   const nsAString& aLocalName)
 470 {
 471   nsRefPtr<mozilla::dom::NodeInfo> ni = GetAttrNodeInfo(aNamespaceURI, aLocalName);
 472   if (!ni) {
 473     return nullptr;
 474   }
 475
 476   return GetAttribute(ni, true);
 477 }
 478
 479 already_AddRefed<mozilla::dom::NodeInfo>
 480 nsDOMAttributeMap::GetAttrNodeInfo(const nsAString& aNamespaceURI,
 481                                    const nsAString& aLocalName)
 482 {
 483   if (!mContent) {
 484     return nullptr;
 485   }
 486
 487   int32_t nameSpaceID = kNameSpaceID_None;
 488
 489   if (!aNamespaceURI.IsEmpty()) {
 490     nameSpaceID =
 491       nsContentUtils::NameSpaceManager()->GetNameSpaceID(aNamespaceURI);
 492
 493     if (nameSpaceID == kNameSpaceID_Unknown) {
 494       return nullptr;
 495     }
 496   }
 497
 498   uint32_t i, count = mContent->GetAttrCount();
 499   for (i = 0; i < count; ++i) {
 500     const nsAttrName* name = mContent->GetAttrNameAt(i);
 501     int32_t attrNS = name->NamespaceID();
 502     nsIAtom* nameAtom = name->LocalName();
 503
 504     if (nameSpaceID == attrNS &&
 505         nameAtom->Equals(aLocalName)) {
 506       nsRefPtr<mozilla::dom::NodeInfo> ni;
 507       ni = mContent->NodeInfo()->NodeInfoManager()->
 508         GetNodeInfo(nameAtom, name->GetPrefix(), nameSpaceID,
 509                     nsIDOMNode::ATTRIBUTE_NODE);
 510
 511       return ni.forget();
 512     }
 513   }
 514
 515   return nullptr;
 516 }
 517
 518 NS_IMETHODIMP
 519 nsDOMAttributeMap::RemoveNamedItemNS(const nsAString& aNamespaceURI,
 520                                      const nsAString& aLocalName,
 521                                      nsIDOMAttr** aReturn)
 522 {
 523   NS_ENSURE_ARG_POINTER(aReturn);
 524   ErrorResult rv;
 525   *aReturn = RemoveNamedItemNS(aNamespaceURI, aLocalName, rv).take();
 526   return rv.ErrorCode();
 527 }
 528
 529 already_AddRefed<Attr>
 530 nsDOMAttributeMap::RemoveNamedItemNS(const nsAString& aNamespaceURI,
 531                                      const nsAString& aLocalName,
 532                                      ErrorResult& aError)
 533 {
 534   nsRefPtr<mozilla::dom::NodeInfo> ni = GetAttrNodeInfo(aNamespaceURI, aLocalName);
 535   if (!ni) {
 536     aError.Throw(NS_ERROR_DOM_NOT_FOUND_ERR);
 537     return nullptr;
 538   }
 539
 540   nsRefPtr<Attr> attr = RemoveAttribute(ni);
 541   mozilla::dom::NodeInfo* attrNi = attr->NodeInfo();
 542   mContent->UnsetAttr(attrNi->NamespaceID(), attrNi->NameAtom(), true);
 543
 544   return attr.forget();
 545 }
 546
 547 uint32_t
 548 nsDOMAttributeMap::Count() const
 549 {
 550   return mAttributeCache ? mAttributeCache->Count() : 0;
 551 }
 552
 553 uint32_t
 554 nsDOMAttributeMap::Enumerate(AttrCache::EnumReadFunction aFunc,
 555                              void *aUserArg) const
 556 {
 557   return mAttributeCache ? mAttributeCache->EnumerateRead(aFunc, aUserArg) : 0;
 558 }
 559
 560 size_t
 561 AttrCacheSizeEnumerator(const nsAttrKey& aKey,
 562                         const nsRefPtr<Attr>& aValue,
 563                         MallocSizeOf aMallocSizeOf,
 564                         void* aUserArg)
 565 {
 566   return aMallocSizeOf(aValue.get());
 567 }
 568
 569 size_t
 570 nsDOMAttributeMap::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const
 571 {
 572   size_t n = aMallocSizeOf(this);
 573   n += mAttributeCache
 574      ? mAttributeCache->SizeOfExcludingThis(AttrCacheSizeEnumerator,
 575                                             aMallocSizeOf)
 576      : 0;
 577
 578   // NB: mContent is non-owning and thus not counted.
 579   return n;
 580 }
 581
 582 /* virtual */ JSObject*
 583 nsDOMAttributeMap::WrapObject(JSContext* aCx)
 584 {
 585   return NamedNodeMapBinding::Wrap(aCx, this);
 586 }