The Tor Browser: comparison content/base/src/nsDOMTokenList.cpp

--1:000000000000
+:49a999ffea52
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+/*
+* Implementation of DOMTokenList specified by HTML5.
+*/
+#include "nsDOMTokenList.h"
+#include "nsAttrValue.h"
+#include "nsContentUtils.h"
+#include "nsError.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/DOMTokenListBinding.h"
+#include "mozilla/ErrorResult.h"
+using namespace mozilla;
+using namespace mozilla::dom;
+nsDOMTokenList::nsDOMTokenList(Element* aElement, nsIAtom* aAttrAtom)
+: mElement(aElement),
+mAttrAtom(aAttrAtom)
+{
+// We don't add a reference to our element. If it goes away,
+// we'll be told to drop our reference
+SetIsDOMBinding();
+}
+nsDOMTokenList::~nsDOMTokenList() { }
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_1(nsDOMTokenList, mElement)
+NS_INTERFACE_MAP_BEGIN(nsDOMTokenList)
+NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_ENTRIES_CYCLE_COLLECTION(nsDOMTokenList)
+NS_INTERFACE_MAP_END
+NS_IMPL_CYCLE_COLLECTING_ADDREF(nsDOMTokenList)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(nsDOMTokenList)
+const nsAttrValue*
+nsDOMTokenList::GetParsedAttr()
+{
+if (!mElement) {
+return nullptr;
+}
+return mElement->GetAttrInfo(kNameSpaceID_None, mAttrAtom).mValue;
+}
+uint32_t
+nsDOMTokenList::Length()
+{
+const nsAttrValue* attr = GetParsedAttr();
+if (!attr) {
+return 0;
+}
+return attr->GetAtomCount();
+}
+void
+nsDOMTokenList::IndexedGetter(uint32_t aIndex, bool& aFound, nsAString& aResult)
+{
+const nsAttrValue* attr = GetParsedAttr();
+if (attr && aIndex < static_cast<uint32_t>(attr->GetAtomCount())) {
+aFound = true;
+attr->AtomAt(aIndex)->ToString(aResult);
+} else {
+aFound = false;
+}
+}
+nsresult
+nsDOMTokenList::CheckToken(const nsAString& aStr)
+{
+if (aStr.IsEmpty()) {
+return NS_ERROR_DOM_SYNTAX_ERR;
+}
+nsAString::const_iterator iter, end;
+aStr.BeginReading(iter);
+aStr.EndReading(end);
+while (iter != end) {
+if (nsContentUtils::IsHTMLWhitespace(*iter))
+return NS_ERROR_DOM_INVALID_CHARACTER_ERR;
+++iter;
+}
+return NS_OK;
+}
+nsresult
+nsDOMTokenList::CheckTokens(const nsTArray<nsString>& aTokens)
+{
+for (uint32_t i = 0, l = aTokens.Length(); i < l; ++i) {
+nsresult rv = CheckToken(aTokens[i]);
+if (NS_FAILED(rv)) {
+return rv;
+}
+}
+return NS_OK;
+}
+bool
+nsDOMTokenList::Contains(const nsAString& aToken, ErrorResult& aError)
+{
+aError = CheckToken(aToken);
+if (aError.Failed()) {
+return false;
+}
+const nsAttrValue* attr = GetParsedAttr();
+return attr && attr->Contains(aToken);
+}
+void
+nsDOMTokenList::AddInternal(const nsAttrValue* aAttr,
+const nsTArray<nsString>& aTokens)
+{
+if (!mElement) {
+return;
+}
+nsAutoString resultStr;
+if (aAttr) {
+aAttr->ToString(resultStr);
+}
+bool oneWasAdded = false;
+nsAutoTArray<nsString, 10> addedClasses;
+for (uint32_t i = 0, l = aTokens.Length(); i < l; ++i) {
+const nsString& aToken = aTokens[i];
+if ((aAttr && aAttr->Contains(aToken)) ||
+addedClasses.Contains(aToken)) {
+continue;
+}
+if (oneWasAdded ||
+(!resultStr.IsEmpty() &&
+!nsContentUtils::IsHTMLWhitespace(resultStr.Last()))) {
+resultStr.Append(NS_LITERAL_STRING(" ") + aToken);
+} else {
+resultStr.Append(aToken);
+}
+oneWasAdded = true;
+addedClasses.AppendElement(aToken);
+}
+mElement->SetAttr(kNameSpaceID_None, mAttrAtom, resultStr, true);
+}
+void
+nsDOMTokenList::Add(const nsTArray<nsString>& aTokens, ErrorResult& aError)
+{
+aError = CheckTokens(aTokens);
+if (aError.Failed()) {
+return;
+}
+const nsAttrValue* attr = GetParsedAttr();
+AddInternal(attr, aTokens);
+}
+void
+nsDOMTokenList::Add(const nsAString& aToken, mozilla::ErrorResult& aError)
+{
+nsAutoTArray<nsString, 1> tokens;
+tokens.AppendElement(aToken);
+Add(tokens, aError);
+}
+void
+nsDOMTokenList::RemoveInternal(const nsAttrValue* aAttr,
+const nsTArray<nsString>& aTokens)
+{
+NS_ABORT_IF_FALSE(aAttr, "Need an attribute");
+nsAutoString input;
+aAttr->ToString(input);
+nsAString::const_iterator copyStart, tokenStart, iter, end;
+input.BeginReading(iter);
+input.EndReading(end);
+copyStart = iter;
+nsAutoString output;
+bool lastTokenRemoved = false;
+while (iter != end) {
+// skip whitespace.
+while (iter != end && nsContentUtils::IsHTMLWhitespace(*iter)) {
+++iter;
+}
+if (iter == end) {
+// At this point we're sure the last seen token (if any) wasn't to be
+// removed. So the trailing spaces will need to be kept.
+NS_ABORT_IF_FALSE(!lastTokenRemoved, "How did this happen?");
+output.Append(Substring(copyStart, end));
+break;
+}
+tokenStart = iter;
+do {
+++iter;
+} while (iter != end && !nsContentUtils::IsHTMLWhitespace(*iter));
+if (aTokens.Contains(Substring(tokenStart, iter))) {
+// Skip whitespace after the token, it will be collapsed.
+while (iter != end && nsContentUtils::IsHTMLWhitespace(*iter)) {
+++iter;
+}
+copyStart = iter;
+lastTokenRemoved = true;
+} else {
+if (lastTokenRemoved && !output.IsEmpty()) {
+NS_ABORT_IF_FALSE(!nsContentUtils::IsHTMLWhitespace(
+output.Last()), "Invalid last output token");
+output.Append(char16_t(' '));
+}
+lastTokenRemoved = false;
+output.Append(Substring(copyStart, iter));
+copyStart = iter;
+}
+}
+mElement->SetAttr(kNameSpaceID_None, mAttrAtom, output, true);
+}
+void
+nsDOMTokenList::Remove(const nsTArray<nsString>& aTokens, ErrorResult& aError)
+{
+aError = CheckTokens(aTokens);
+if (aError.Failed()) {
+return;
+}
+const nsAttrValue* attr = GetParsedAttr();
+if (!attr) {
+return;
+}
+RemoveInternal(attr, aTokens);
+}
+void
+nsDOMTokenList::Remove(const nsAString& aToken, mozilla::ErrorResult& aError)
+{
+nsAutoTArray<nsString, 1> tokens;
+tokens.AppendElement(aToken);
+Remove(tokens, aError);
+}
+bool
+nsDOMTokenList::Toggle(const nsAString& aToken,
+const Optional<bool>& aForce,
+ErrorResult& aError)
+{
+aError = CheckToken(aToken);
+if (aError.Failed()) {
+return false;
+}
+const nsAttrValue* attr = GetParsedAttr();
+const bool forceOn = aForce.WasPassed() && aForce.Value();
+const bool forceOff = aForce.WasPassed() && !aForce.Value();
+bool isPresent = attr && attr->Contains(aToken);
+nsAutoTArray<nsString, 1> tokens;
+(*tokens.AppendElement()).Rebind(aToken.Data(), aToken.Length());
+if (isPresent) {
+if (!forceOn) {
+RemoveInternal(attr, tokens);
+isPresent = false;
+}
+} else {
+if (!forceOff) {
+AddInternal(attr, tokens);
+isPresent = true;
+}
+}
+return isPresent;
+}
+void
+nsDOMTokenList::Stringify(nsAString& aResult)
+{
+if (!mElement) {
+aResult.Truncate();
+return;
+}
+mElement->GetAttr(kNameSpaceID_None, mAttrAtom, aResult);
+}
+JSObject*
+nsDOMTokenList::WrapObject(JSContext *cx)
+{
+return DOMTokenListBinding::Wrap(cx, this);
+}

The Tor Browser / file comparison

comparison: content/base/src/nsDOMTokenList.cpp

content/base/src/nsDOMTokenList.cpp