dom/base/nsDOMTokenList.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 DOMTokenList specified by HTML5.
   9  */
  10
  11 #include "nsDOMTokenList.h"
  12 #include "nsAttrValue.h"
  13 #include "nsAttrValueInlines.h"
  14 #include "nsTHashMap.h"
  15 #include "nsError.h"
  16 #include "nsHashKeys.h"
  17 #include "mozilla/dom/Document.h"
  18 #include "mozilla/dom/Element.h"
  19 #include "mozilla/dom/DOMTokenListBinding.h"
  20 #include "mozilla/BloomFilter.h"
  21 #include "mozilla/ErrorResult.h"
  22
  23 using namespace mozilla;
  24 using namespace mozilla::dom;
  25
  26 nsDOMTokenList::nsDOMTokenList(
  27     Element* aElement, nsAtom* aAttrAtom,
  28     const DOMTokenListSupportedTokenArray aSupportedTokens)
  29     : mElement(aElement),
  30       mAttrAtom(aAttrAtom),
  31       mSupportedTokens(aSupportedTokens) {
  32   // We don't add a reference to our element. If it goes away,
  33   // we'll be told to drop our reference
  34 }
  35
  36 nsDOMTokenList::~nsDOMTokenList() = default;
  37
  38 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(nsDOMTokenList, mElement)
  39
  40 NS_INTERFACE_MAP_BEGIN(nsDOMTokenList)
  41   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
  42   NS_INTERFACE_MAP_ENTRY(nsISupports)
  43   NS_INTERFACE_MAP_ENTRIES_CYCLE_COLLECTION(nsDOMTokenList)
  44 NS_INTERFACE_MAP_END
  45
  46 NS_IMPL_CYCLE_COLLECTING_ADDREF(nsDOMTokenList)
  47 NS_IMPL_CYCLE_COLLECTING_RELEASE(nsDOMTokenList)
  48
  49 const nsAttrValue* nsDOMTokenList::GetParsedAttr() {
  50   if (!mElement) {
  51     return nullptr;
  52   }
  53   return mElement->GetAttrInfo(kNameSpaceID_None, mAttrAtom).mValue;
  54 }
  55
  56 static void RemoveDuplicatesInternal(AtomArray* aArray, uint32_t aStart) {
  57   nsTHashMap<nsPtrHashKey<nsAtom>, bool> tokens;
  58
  59   for (uint32_t i = 0; i < aArray->Length(); i++) {
  60     nsAtom* atom = aArray->ElementAt(i);
  61     // No need to check the hashtable below aStart
  62     if (i >= aStart && tokens.Get(atom)) {
  63       aArray->RemoveElementAt(i);
  64       i--;
  65     } else {
  66       tokens.InsertOrUpdate(atom, true);
  67     }
  68   }
  69 }
  70
  71 void nsDOMTokenList::RemoveDuplicates(const nsAttrValue* aAttr) {
  72   if (!aAttr || aAttr->Type() != nsAttrValue::eAtomArray) {
  73     return;
  74   }
  75
  76   BitBloomFilter<8, nsAtom> filter;
  77   AtomArray* array = aAttr->GetAtomArrayValue();
  78   for (uint32_t i = 0; i < array->Length(); i++) {
  79     nsAtom* atom = array->ElementAt(i);
  80     if (filter.mightContain(atom)) {
  81       // Start again, with a hashtable
  82       RemoveDuplicatesInternal(array, i);
  83       return;
  84     } else {
  85       filter.add(atom);
  86     }
  87   }
  88 }
  89
  90 uint32_t nsDOMTokenList::Length() {
  91   const nsAttrValue* attr = GetParsedAttr();
  92   if (!attr) {
  93     return 0;
  94   }
  95
  96   RemoveDuplicates(attr);
  97   return attr->GetAtomCount();
  98 }
  99
 100 void nsDOMTokenList::IndexedGetter(uint32_t aIndex, bool& aFound,
 101                                    nsAString& aResult) {
 102   const nsAttrValue* attr = GetParsedAttr();
 103
 104   if (!attr || aIndex >= static_cast<uint32_t>(attr->GetAtomCount())) {
 105     aFound = false;
 106     return;
 107   }
 108
 109   RemoveDuplicates(attr);
 110
 111   if (attr && aIndex < static_cast<uint32_t>(attr->GetAtomCount())) {
 112     aFound = true;
 113     attr->AtomAt(aIndex)->ToString(aResult);
 114   } else {
 115     aFound = false;
 116   }
 117 }
 118
 119 void nsDOMTokenList::GetValue(nsAString& aResult) {
 120   if (!mElement) {
 121     aResult.Truncate();
 122     return;
 123   }
 124
 125   mElement->GetAttr(kNameSpaceID_None, mAttrAtom, aResult);
 126 }
 127
 128 void nsDOMTokenList::SetValue(const nsAString& aValue, ErrorResult& rv) {
 129   if (!mElement) {
 130     return;
 131   }
 132
 133   rv = mElement->SetAttr(kNameSpaceID_None, mAttrAtom, aValue, true);
 134 }
 135
 136 nsresult nsDOMTokenList::CheckToken(const nsAString& aStr) {
 137   if (aStr.IsEmpty()) {
 138     return NS_ERROR_DOM_SYNTAX_ERR;
 139   }
 140
 141   nsAString::const_iterator iter, end;
 142   aStr.BeginReading(iter);
 143   aStr.EndReading(end);
 144
 145   while (iter != end) {
 146     if (nsContentUtils::IsHTMLWhitespace(*iter))
 147       return NS_ERROR_DOM_INVALID_CHARACTER_ERR;
 148     ++iter;
 149   }
 150
 151   return NS_OK;
 152 }
 153
 154 nsresult nsDOMTokenList::CheckTokens(const nsTArray<nsString>& aTokens) {
 155   for (uint32_t i = 0, l = aTokens.Length(); i < l; ++i) {
 156     nsresult rv = CheckToken(aTokens[i]);
 157     if (NS_FAILED(rv)) {
 158       return rv;
 159     }
 160   }
 161
 162   return NS_OK;
 163 }
 164
 165 bool nsDOMTokenList::Contains(const nsAString& aToken) {
 166   const nsAttrValue* attr = GetParsedAttr();
 167   return attr && attr->Contains(aToken);
 168 }
 169
 170 void nsDOMTokenList::AddInternal(const nsAttrValue* aAttr,
 171                                  const nsTArray<nsString>& aTokens) {
 172   if (!mElement) {
 173     return;
 174   }
 175
 176   nsAutoString resultStr;
 177
 178   if (aAttr) {
 179     RemoveDuplicates(aAttr);
 180     for (uint32_t i = 0; i < aAttr->GetAtomCount(); i++) {
 181       if (i != 0) {
 182         resultStr.AppendLiteral(" ");
 183       }
 184       resultStr.Append(nsDependentAtomString(aAttr->AtomAt(i)));
 185     }
 186   }
 187
 188   AutoTArray<nsString, 10> addedClasses;
 189
 190   for (uint32_t i = 0, l = aTokens.Length(); i < l; ++i) {
 191     const nsString& aToken = aTokens[i];
 192
 193     if ((aAttr && aAttr->Contains(aToken)) || addedClasses.Contains(aToken)) {
 194       continue;
 195     }
 196
 197     if (!resultStr.IsEmpty()) {
 198       resultStr.Append(' ');
 199     }
 200     resultStr.Append(aToken);
 201
 202     addedClasses.AppendElement(aToken);
 203   }
 204
 205   mElement->SetAttr(kNameSpaceID_None, mAttrAtom, resultStr, true);
 206 }
 207
 208 void nsDOMTokenList::Add(const nsTArray<nsString>& aTokens,
 209                          ErrorResult& aError) {
 210   aError = CheckTokens(aTokens);
 211   if (aError.Failed()) {
 212     return;
 213   }
 214
 215   const nsAttrValue* attr = GetParsedAttr();
 216   AddInternal(attr, aTokens);
 217 }
 218
 219 void nsDOMTokenList::Add(const nsAString& aToken, ErrorResult& aError) {
 220   AutoTArray<nsString, 1> tokens;
 221   tokens.AppendElement(aToken);
 222   Add(tokens, aError);
 223 }
 224
 225 void nsDOMTokenList::RemoveInternal(const nsAttrValue* aAttr,
 226                                     const nsTArray<nsString>& aTokens) {
 227   MOZ_ASSERT(aAttr, "Need an attribute");
 228
 229   RemoveDuplicates(aAttr);
 230
 231   nsAutoString resultStr;
 232   for (uint32_t i = 0; i < aAttr->GetAtomCount(); i++) {
 233     if (aTokens.Contains(nsDependentAtomString(aAttr->AtomAt(i)))) {
 234       continue;
 235     }
 236     if (!resultStr.IsEmpty()) {
 237       resultStr.AppendLiteral(" ");
 238     }
 239     resultStr.Append(nsDependentAtomString(aAttr->AtomAt(i)));
 240   }
 241
 242   mElement->SetAttr(kNameSpaceID_None, mAttrAtom, resultStr, true);
 243 }
 244
 245 void nsDOMTokenList::Remove(const nsTArray<nsString>& aTokens,
 246                             ErrorResult& aError) {
 247   aError = CheckTokens(aTokens);
 248   if (aError.Failed()) {
 249     return;
 250   }
 251
 252   const nsAttrValue* attr = GetParsedAttr();
 253   if (!attr) {
 254     return;
 255   }
 256
 257   RemoveInternal(attr, aTokens);
 258 }
 259
 260 void nsDOMTokenList::Remove(const nsAString& aToken, ErrorResult& aError) {
 261   AutoTArray<nsString, 1> tokens;
 262   tokens.AppendElement(aToken);
 263   Remove(tokens, aError);
 264 }
 265
 266 bool nsDOMTokenList::Toggle(const nsAString& aToken,
 267                             const Optional<bool>& aForce, ErrorResult& aError) {
 268   aError = CheckToken(aToken);
 269   if (aError.Failed()) {
 270     return false;
 271   }
 272
 273   const nsAttrValue* attr = GetParsedAttr();
 274   const bool forceOn = aForce.WasPassed() && aForce.Value();
 275   const bool forceOff = aForce.WasPassed() && !aForce.Value();
 276
 277   bool isPresent = attr && attr->Contains(aToken);
 278   AutoTArray<nsString, 1> tokens;
 279   (*tokens.AppendElement()).Rebind(aToken.Data(), aToken.Length());
 280
 281   if (isPresent) {
 282     if (!forceOn) {
 283       RemoveInternal(attr, tokens);
 284       isPresent = false;
 285     }
 286   } else {
 287     if (!forceOff) {
 288       AddInternal(attr, tokens);
 289       isPresent = true;
 290     }
 291   }
 292
 293   return isPresent;
 294 }
 295
 296 bool nsDOMTokenList::Replace(const nsAString& aToken,
 297                              const nsAString& aNewToken, ErrorResult& aError) {
 298   // Doing this here instead of using `CheckToken` because if aToken had invalid
 299   // characters, and aNewToken is empty, the returned error should be a
 300   // SyntaxError, not an InvalidCharacterError.
 301   if (aNewToken.IsEmpty()) {
 302     aError.Throw(NS_ERROR_DOM_SYNTAX_ERR);
 303     return false;
 304   }
 305
 306   aError = CheckToken(aToken);
 307   if (aError.Failed()) {
 308     return false;
 309   }
 310
 311   aError = CheckToken(aNewToken);
 312   if (aError.Failed()) {
 313     return false;
 314   }
 315
 316   const nsAttrValue* attr = GetParsedAttr();
 317   if (!attr) {
 318     return false;
 319   }
 320
 321   return ReplaceInternal(attr, aToken, aNewToken);
 322 }
 323
 324 bool nsDOMTokenList::ReplaceInternal(const nsAttrValue* aAttr,
 325                                      const nsAString& aToken,
 326                                      const nsAString& aNewToken) {
 327   RemoveDuplicates(aAttr);
 328
 329   // Trying to do a single pass here leads to really complicated code.  Just do
 330   // the simple thing.
 331   bool haveOld = false;
 332   for (uint32_t i = 0; i < aAttr->GetAtomCount(); ++i) {
 333     if (aAttr->AtomAt(i)->Equals(aToken)) {
 334       haveOld = true;
 335       break;
 336     }
 337   }
 338   if (!haveOld) {
 339     // Make sure to not touch the attribute value in this case.
 340     return false;
 341   }
 342
 343   bool sawIt = false;
 344   nsAutoString resultStr;
 345   for (uint32_t i = 0; i < aAttr->GetAtomCount(); i++) {
 346     if (aAttr->AtomAt(i)->Equals(aToken) ||
 347         aAttr->AtomAt(i)->Equals(aNewToken)) {
 348       if (sawIt) {
 349         // We keep only the first
 350         continue;
 351       }
 352       sawIt = true;
 353       if (!resultStr.IsEmpty()) {
 354         resultStr.AppendLiteral(" ");
 355       }
 356       resultStr.Append(aNewToken);
 357       continue;
 358     }
 359     if (!resultStr.IsEmpty()) {
 360       resultStr.AppendLiteral(" ");
 361     }
 362     resultStr.Append(nsDependentAtomString(aAttr->AtomAt(i)));
 363   }
 364
 365   MOZ_ASSERT(sawIt, "How could we not have found our token this time?");
 366   mElement->SetAttr(kNameSpaceID_None, mAttrAtom, resultStr, true);
 367   return true;
 368 }
 369
 370 bool nsDOMTokenList::Supports(const nsAString& aToken, ErrorResult& aError) {
 371   if (!mSupportedTokens) {
 372     aError.ThrowTypeError<MSG_TOKENLIST_NO_SUPPORTED_TOKENS>(
 373         NS_ConvertUTF16toUTF8(mElement->LocalName()),
 374         NS_ConvertUTF16toUTF8(nsDependentAtomString(mAttrAtom)));
 375     return false;
 376   }
 377
 378   for (DOMTokenListSupportedToken* supportedToken = mSupportedTokens;
 379        *supportedToken; ++supportedToken) {
 380     if (aToken.LowerCaseEqualsASCII(*supportedToken)) {
 381       return true;
 382     }
 383   }
 384
 385   return false;
 386 }
 387
 388 DocGroup* nsDOMTokenList::GetDocGroup() const {
 389   return mElement ? mElement->OwnerDoc()->GetDocGroup() : nullptr;
 390 }
 391
 392 JSObject* nsDOMTokenList::WrapObject(JSContext* cx,
 393                                      JS::Handle<JSObject*> aGivenProto) {
 394   return DOMTokenList_Binding::Wrap(cx, this, aGivenProto);
 395 }