dom/base/nsDOMTokenList.cpp

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 /*
   6  * Implementation of DOMTokenList specified by HTML5.
   7  */
   8
   9 #include "nsDOMTokenList.h"
  10
  11 #include "nsAttrValue.h"
  12 #include "nsContentUtils.h"
  13 #include "nsError.h"
  14 #include "mozilla/dom/Element.h"
  15 #include "mozilla/dom/DOMTokenListBinding.h"
  16 #include "mozilla/ErrorResult.h"
  17
  18 using namespace mozilla;
  19 using namespace mozilla::dom;
  20
  21 nsDOMTokenList::nsDOMTokenList(Element* aElement, nsIAtom* aAttrAtom)
  22   : mElement(aElement),
  23     mAttrAtom(aAttrAtom)
  24 {
  25   // We don't add a reference to our element. If it goes away,
  26   // we'll be told to drop our reference
  27 }
  28
  29 nsDOMTokenList::~nsDOMTokenList() { }
  30
  31 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(nsDOMTokenList, mElement)
  32
  33 NS_INTERFACE_MAP_BEGIN(nsDOMTokenList)
  34   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
  35   NS_INTERFACE_MAP_ENTRY(nsISupports)
  36   NS_INTERFACE_MAP_ENTRIES_CYCLE_COLLECTION(nsDOMTokenList)
  37 NS_INTERFACE_MAP_END
  38
  39 NS_IMPL_CYCLE_COLLECTING_ADDREF(nsDOMTokenList)
  40 NS_IMPL_CYCLE_COLLECTING_RELEASE(nsDOMTokenList)
  41
  42 const nsAttrValue*
  43 nsDOMTokenList::GetParsedAttr()
  44 {
  45   if (!mElement) {
  46     return nullptr;
  47   }
  48   return mElement->GetAttrInfo(kNameSpaceID_None, mAttrAtom).mValue;
  49 }
  50
  51 uint32_t
  52 nsDOMTokenList::Length()
  53 {
  54   const nsAttrValue* attr = GetParsedAttr();
  55   if (!attr) {
  56     return 0;
  57   }
  58
  59   return attr->GetAtomCount();
  60 }
  61
  62 void
  63 nsDOMTokenList::IndexedGetter(uint32_t aIndex, bool& aFound, nsAString& aResult)
  64 {
  65   const nsAttrValue* attr = GetParsedAttr();
  66
  67   if (attr && aIndex < static_cast<uint32_t>(attr->GetAtomCount())) {
  68     aFound = true;
  69     attr->AtomAt(aIndex)->ToString(aResult);
  70   } else {
  71     aFound = false;
  72   }
  73 }
  74
  75 nsresult
  76 nsDOMTokenList::CheckToken(const nsAString& aStr)
  77 {
  78   if (aStr.IsEmpty()) {
  79     return NS_ERROR_DOM_SYNTAX_ERR;
  80   }
  81
  82   nsAString::const_iterator iter, end;
  83   aStr.BeginReading(iter);
  84   aStr.EndReading(end);
  85
  86   while (iter != end) {
  87     if (nsContentUtils::IsHTMLWhitespace(*iter))
  88       return NS_ERROR_DOM_INVALID_CHARACTER_ERR;
  89     ++iter;
  90   }
  91
  92   return NS_OK;
  93 }
  94
  95 nsresult
  96 nsDOMTokenList::CheckTokens(const nsTArray<nsString>& aTokens)
  97 {
  98   for (uint32_t i = 0, l = aTokens.Length(); i < l; ++i) {
  99     nsresult rv = CheckToken(aTokens[i]);
 100     if (NS_FAILED(rv)) {
 101       return rv;
 102     }
 103   }
 104
 105   return NS_OK;
 106 }
 107
 108 bool
 109 nsDOMTokenList::Contains(const nsAString& aToken, ErrorResult& aError)
 110 {
 111   aError = CheckToken(aToken);
 112   if (aError.Failed()) {
 113     return false;
 114   }
 115
 116   const nsAttrValue* attr = GetParsedAttr();
 117   return attr && attr->Contains(aToken);
 118 }
 119
 120 void
 121 nsDOMTokenList::AddInternal(const nsAttrValue* aAttr,
 122                             const nsTArray<nsString>& aTokens)
 123 {
 124   if (!mElement) {
 125     return;
 126   }
 127
 128   nsAutoString resultStr;
 129
 130   if (aAttr) {
 131     aAttr->ToString(resultStr);
 132   }
 133
 134   bool oneWasAdded = false;
 135   nsAutoTArray<nsString, 10> addedClasses;
 136
 137   for (uint32_t i = 0, l = aTokens.Length(); i < l; ++i) {
 138     const nsString& aToken = aTokens[i];
 139
 140     if ((aAttr && aAttr->Contains(aToken)) ||
 141         addedClasses.Contains(aToken)) {
 142       continue;
 143     }
 144
 145     if (oneWasAdded ||
 146         (!resultStr.IsEmpty() &&
 147         !nsContentUtils::IsHTMLWhitespace(resultStr.Last()))) {
 148       resultStr.Append(' ');
 149       resultStr.Append(aToken);
 150     } else {
 151       resultStr.Append(aToken);
 152     }
 153
 154     oneWasAdded = true;
 155     addedClasses.AppendElement(aToken);
 156   }
 157
 158   mElement->SetAttr(kNameSpaceID_None, mAttrAtom, resultStr, true);
 159 }
 160
 161 void
 162 nsDOMTokenList::Add(const nsTArray<nsString>& aTokens, ErrorResult& aError)
 163 {
 164   aError = CheckTokens(aTokens);
 165   if (aError.Failed()) {
 166     return;
 167   }
 168
 169   const nsAttrValue* attr = GetParsedAttr();
 170   AddInternal(attr, aTokens);
 171 }
 172
 173 void
 174 nsDOMTokenList::Add(const nsAString& aToken, mozilla::ErrorResult& aError)
 175 {
 176   nsAutoTArray<nsString, 1> tokens;
 177   tokens.AppendElement(aToken);
 178   Add(tokens, aError);
 179 }
 180
 181 void
 182 nsDOMTokenList::RemoveInternal(const nsAttrValue* aAttr,
 183                                const nsTArray<nsString>& aTokens)
 184 {
 185   NS_ABORT_IF_FALSE(aAttr, "Need an attribute");
 186
 187   nsAutoString input;
 188   aAttr->ToString(input);
 189
 190   nsAString::const_iterator copyStart, tokenStart, iter, end;
 191   input.BeginReading(iter);
 192   input.EndReading(end);
 193   copyStart = iter;
 194
 195   nsAutoString output;
 196   bool lastTokenRemoved = false;
 197
 198   while (iter != end) {
 199     // skip whitespace.
 200     while (iter != end && nsContentUtils::IsHTMLWhitespace(*iter)) {
 201       ++iter;
 202     }
 203
 204     if (iter == end) {
 205       // At this point we're sure the last seen token (if any) wasn't to be
 206       // removed. So the trailing spaces will need to be kept.
 207       NS_ABORT_IF_FALSE(!lastTokenRemoved, "How did this happen?");
 208
 209       output.Append(Substring(copyStart, end));
 210       break;
 211     }
 212
 213     tokenStart = iter;
 214     do {
 215       ++iter;
 216     } while (iter != end && !nsContentUtils::IsHTMLWhitespace(*iter));
 217
 218     if (aTokens.Contains(Substring(tokenStart, iter))) {
 219
 220       // Skip whitespace after the token, it will be collapsed.
 221       while (iter != end && nsContentUtils::IsHTMLWhitespace(*iter)) {
 222         ++iter;
 223       }
 224       copyStart = iter;
 225       lastTokenRemoved = true;
 226
 227     } else {
 228
 229       if (lastTokenRemoved && !output.IsEmpty()) {
 230         NS_ABORT_IF_FALSE(!nsContentUtils::IsHTMLWhitespace(
 231           output.Last()), "Invalid last output token");
 232         output.Append(char16_t(' '));
 233       }
 234       lastTokenRemoved = false;
 235       output.Append(Substring(copyStart, iter));
 236       copyStart = iter;
 237     }
 238   }
 239
 240   mElement->SetAttr(kNameSpaceID_None, mAttrAtom, output, true);
 241 }
 242
 243 void
 244 nsDOMTokenList::Remove(const nsTArray<nsString>& aTokens, ErrorResult& aError)
 245 {
 246   aError = CheckTokens(aTokens);
 247   if (aError.Failed()) {
 248     return;
 249   }
 250
 251   const nsAttrValue* attr = GetParsedAttr();
 252   if (!attr) {
 253     return;
 254   }
 255
 256   RemoveInternal(attr, aTokens);
 257 }
 258
 259 void
 260 nsDOMTokenList::Remove(const nsAString& aToken, mozilla::ErrorResult& aError)
 261 {
 262   nsAutoTArray<nsString, 1> tokens;
 263   tokens.AppendElement(aToken);
 264   Remove(tokens, aError);
 265 }
 266
 267 bool
 268 nsDOMTokenList::Toggle(const nsAString& aToken,
 269                        const Optional<bool>& aForce,
 270                        ErrorResult& aError)
 271 {
 272   aError = CheckToken(aToken);
 273   if (aError.Failed()) {
 274     return false;
 275   }
 276
 277   const nsAttrValue* attr = GetParsedAttr();
 278   const bool forceOn = aForce.WasPassed() && aForce.Value();
 279   const bool forceOff = aForce.WasPassed() && !aForce.Value();
 280
 281   bool isPresent = attr && attr->Contains(aToken);
 282   nsAutoTArray<nsString, 1> tokens;
 283   (*tokens.AppendElement()).Rebind(aToken.Data(), aToken.Length());
 284
 285   if (isPresent) {
 286     if (!forceOn) {
 287       RemoveInternal(attr, tokens);
 288       isPresent = false;
 289     }
 290   } else {
 291     if (!forceOff) {
 292       AddInternal(attr, tokens);
 293       isPresent = true;
 294     }
 295   }
 296
 297   return isPresent;
 298 }
 299
 300 void
 301 nsDOMTokenList::Stringify(nsAString& aResult)
 302 {
 303   if (!mElement) {
 304     aResult.Truncate();
 305     return;
 306   }
 307
 308   mElement->GetAttr(kNameSpaceID_None, mAttrAtom, aResult);
 309 }
 310
 311 JSObject*
 312 nsDOMTokenList::WrapObject(JSContext *cx)
 313 {
 314   return DOMTokenListBinding::Wrap(cx, this);
 315 }
 316