third_party/WebKit/Source/core/dom/DOMTokenList.cpp - chromium/src - Git at Google

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
  *     documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR
  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 #include "core/dom/DOMTokenList.h"

 #include "bindings/core/v8/ExceptionState.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 #include "wtf/text/StringBuilder.h"

 namespace blink {

 namespace {

 class DOMTokenListIterationSource final
     : public ValueIterable<String>::IterationSource {
  public:
   explicit DOMTokenListIterationSource(DOMTokenList* domTokenList)
       : m_domTokenList(domTokenList) {}

   bool next(ScriptState* scriptState,
             String& value,
             ExceptionState& exceptionState) override {
     if (m_index >= m_domTokenList->length())
       return false;
     value = m_domTokenList->item(m_index);
     return true;
   }

   DEFINE_INLINE_VIRTUAL_TRACE() {
     visitor->trace(m_domTokenList);
     ValueIterable<String>::IterationSource::trace(visitor);
   }

  private:
   const Member<DOMTokenList> m_domTokenList;
 };

 }  // namespace

 bool DOMTokenList::validateToken(const String& token,
                                  ExceptionState& exceptionState) const {
   if (token.isEmpty()) {
     exceptionState.throwDOMException(SyntaxError,
                                      "The token provided must not be empty.");
     return false;
   }

   if (token.find(isHTMLSpace) != kNotFound) {
     exceptionState.throwDOMException(InvalidCharacterError,
                                      "The token provided ('" + token +
                                          "') contains HTML space characters, "
                                          "which are not valid in tokens.");
     return false;
   }

   return true;
 }

 bool DOMTokenList::validateTokens(const Vector<String>& tokens,
                                   ExceptionState& exceptionState) const {
   for (size_t i = 0; i < tokens.size(); ++i) {
     if (!validateToken(tokens[i], exceptionState))
       return false;
   }

   return true;
 }

 // https://dom.spec.whatwg.org/#concept-domtokenlist-validation
 bool DOMTokenList::validateTokenValue(const AtomicString&,
                                       ExceptionState& exceptionState) const {
   exceptionState.throwTypeError("DOMTokenList has no supported tokens.");
   return false;
 }

 bool DOMTokenList::contains(const AtomicString& token,
                             ExceptionState& exceptionState) const {
   if (!validateToken(token, exceptionState))
     return false;
   return containsInternal(token);
 }

 void DOMTokenList::add(const AtomicString& token,
                        ExceptionState& exceptionState) {
   Vector<String> tokens;
   tokens.append(token.getString());
   add(tokens, exceptionState);
 }

 // Optimally, this should take a Vector<AtomicString> const ref in argument but
 // the bindings generator does not handle that.
 void DOMTokenList::add(const Vector<String>& tokens,
                        ExceptionState& exceptionState) {
   Vector<String> filteredTokens;
   filteredTokens.reserveCapacity(tokens.size());
   for (size_t i = 0; i < tokens.size(); ++i) {
     if (!validateToken(tokens[i], exceptionState))
       return;
     if (containsInternal(AtomicString(tokens[i])))
       continue;
     if (filteredTokens.contains(tokens[i]))
       continue;
     filteredTokens.append(tokens[i]);
   }

   if (!filteredTokens.isEmpty())
     setValue(addTokens(value(), filteredTokens));
 }

 void DOMTokenList::remove(const AtomicString& token,
                           ExceptionState& exceptionState) {
   Vector<String> tokens;
   tokens.append(token.getString());
   remove(tokens, exceptionState);
 }

 // Optimally, this should take a Vector<AtomicString> const ref in argument but
 // the bindings generator does not handle that.
 void DOMTokenList::remove(const Vector<String>& tokens,
                           ExceptionState& exceptionState) {
   if (!validateTokens(tokens, exceptionState))
     return;

   // Check using containsInternal first since it is a lot faster than going
   // through the string character by character.
   bool found = false;
   for (size_t i = 0; i < tokens.size(); ++i) {
     if (containsInternal(AtomicString(tokens[i]))) {
       found = true;
       break;
     }
   }

   if (found)
     setValue(removeTokens(value(), tokens));
 }

 bool DOMTokenList::toggle(const AtomicString& token,
                           ExceptionState& exceptionState) {
   if (!validateToken(token, exceptionState))
     return false;

   if (containsInternal(token)) {
     removeInternal(token);
     return false;
   }
   addInternal(token);
   return true;
 }

 bool DOMTokenList::toggle(const AtomicString& token,
                           bool force,
                           ExceptionState& exceptionState) {
   if (!validateToken(token, exceptionState))
     return false;

   if (force)
     addInternal(token);
   else
     removeInternal(token);

   return force;
 }

 bool DOMTokenList::supports(const AtomicString& token,
                             ExceptionState& exceptionState) {
   return validateTokenValue(token, exceptionState);
 }

 void DOMTokenList::addInternal(const AtomicString& token) {
   if (!containsInternal(token))
     setValue(addToken(value(), token));
 }

 void DOMTokenList::removeInternal(const AtomicString& token) {
   // Check using contains first since it uses AtomicString comparisons instead
   // of character by character testing.
   if (!containsInternal(token))
     return;
   setValue(removeToken(value(), token));
 }

 AtomicString DOMTokenList::addToken(const AtomicString& input,
                                     const AtomicString& token) {
   Vector<String> tokens;
   tokens.append(token.getString());
   return addTokens(input, tokens);
 }

 // This returns an AtomicString because it is always passed as argument to
 // setValue() and setValue() takes an AtomicString in argument.
 AtomicString DOMTokenList::addTokens(const AtomicString& input,
                                      const Vector<String>& tokens) {
   bool needsSpace = false;

   StringBuilder builder;
   if (!input.isEmpty()) {
     builder.append(input);
     needsSpace = !isHTMLSpace<UChar>(input[input.length() - 1]);
   }

   for (size_t i = 0; i < tokens.size(); ++i) {
     if (needsSpace)
       builder.append(' ');
     builder.append(tokens[i]);
     needsSpace = true;
   }

   return builder.toAtomicString();
 }

 AtomicString DOMTokenList::removeToken(const AtomicString& input,
                                        const AtomicString& token) {
   Vector<String> tokens;
   tokens.append(token.getString());
   return removeTokens(input, tokens);
 }

 // This returns an AtomicString because it is always passed as argument to
 // setValue() and setValue() takes an AtomicString in argument.
 AtomicString DOMTokenList::removeTokens(const AtomicString& input,
                                         const Vector<String>& tokens) {
   // Algorithm defined at
   // http://www.whatwg.org/specs/web-apps/current-work/multipage/common-microsyntaxes.html#remove-a-token-from-a-string
   // New spec is at https://dom.spec.whatwg.org/#remove-a-token-from-a-string

   unsigned inputLength = input.length();
   StringBuilder output;  // 3
   output.reserveCapacity(inputLength);
   unsigned position = 0;  // 4

   // Step 5
   while (position < inputLength) {
     if (isHTMLSpace<UChar>(input[position])) {  // 6
       position++;
       continue;  // 6.3
     }

     // Step 7
     StringBuilder tokenBuilder;
     while (position < inputLength && isNotHTMLSpace<UChar>(input[position]))
       tokenBuilder.append(input[position++]);

     // Step 8
     String token = tokenBuilder.toString();
     if (tokens.contains(token)) {
       // Step 8.1
       while (position < inputLength && isHTMLSpace<UChar>(input[position]))
         ++position;

       // Step 8.2
       size_t j = output.length();
       while (j > 0 && isHTMLSpace<UChar>(output[j - 1]))
         --j;
       output.resize(j);
     } else {
       output.append(token);  // Step 9
     }

     if (position < inputLength && !output.isEmpty())
       output.append(' ');
   }

   size_t j = output.length();
   if (j > 0 && isHTMLSpace<UChar>(output[j - 1]))
     output.resize(j - 1);

   return output.toAtomicString();
 }

 void DOMTokenList::setValue(const AtomicString& value) {
   m_value = value;
   m_tokens.set(value, SpaceSplitString::ShouldNotFoldCase);
   if (m_observer)
     m_observer->valueWasSet();
 }

 bool DOMTokenList::containsInternal(const AtomicString& token) const {
   return m_tokens.contains(token);
 }

 ValueIterable<String>::IterationSource* DOMTokenList::startIteration(
     ScriptState*,
     ExceptionState&) {
   return new DOMTokenListIterationSource(this);
 }

 const AtomicString DOMTokenList::item(unsigned index) const {
   if (index >= length())
     return AtomicString();
   return m_tokens[index];
 }

 }  // namespace blink
	/*
	* Copyright (C) 2010 Google Inc. All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	*
	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND
	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
	* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	* DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR
	* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#include "core/dom/DOMTokenList.h"

	#include "bindings/core/v8/ExceptionState.h"
	#include "core/dom/ExceptionCode.h"
	#include "core/html/parser/HTMLParserIdioms.h"
	#include "wtf/text/StringBuilder.h"

	namespace blink {

	namespace {

	class DOMTokenListIterationSource final
	: public ValueIterable<String>::IterationSource {
	public:
	explicit DOMTokenListIterationSource(DOMTokenList* domTokenList)
	: m_domTokenList(domTokenList) {}

	bool next(ScriptState* scriptState,
	String& value,
	ExceptionState& exceptionState) override {
	if (m_index >= m_domTokenList->length())
	return false;
	value = m_domTokenList->item(m_index);
	return true;
	}

	DEFINE_INLINE_VIRTUAL_TRACE() {
	visitor->trace(m_domTokenList);
	ValueIterable<String>::IterationSource::trace(visitor);
	}

	private:
	const Member<DOMTokenList> m_domTokenList;
	};

	} // namespace

	bool DOMTokenList::validateToken(const String& token,
	ExceptionState& exceptionState) const {
	if (token.isEmpty()) {
	exceptionState.throwDOMException(SyntaxError,
	"The token provided must not be empty.");
	return false;
	}

	if (token.find(isHTMLSpace) != kNotFound) {
	exceptionState.throwDOMException(InvalidCharacterError,
	"The token provided ('" + token +
	"') contains HTML space characters, "
	"which are not valid in tokens.");
	return false;
	}

	return true;
	}

	bool DOMTokenList::validateTokens(const Vector<String>& tokens,
	ExceptionState& exceptionState) const {
	for (size_t i = 0; i < tokens.size(); ++i) {
	if (!validateToken(tokens[i], exceptionState))
	return false;
	}

	return true;
	}

	// https://dom.spec.whatwg.org/#concept-domtokenlist-validation
	bool DOMTokenList::validateTokenValue(const AtomicString&,
	ExceptionState& exceptionState) const {
	exceptionState.throwTypeError("DOMTokenList has no supported tokens.");
	return false;
	}

	bool DOMTokenList::contains(const AtomicString& token,
	ExceptionState& exceptionState) const {
	if (!validateToken(token, exceptionState))
	return false;
	return containsInternal(token);
	}

	void DOMTokenList::add(const AtomicString& token,
	ExceptionState& exceptionState) {
	Vector<String> tokens;
	tokens.append(token.getString());
	add(tokens, exceptionState);
	}

	// Optimally, this should take a Vector<AtomicString> const ref in argument but
	// the bindings generator does not handle that.
	void DOMTokenList::add(const Vector<String>& tokens,
	ExceptionState& exceptionState) {
	Vector<String> filteredTokens;
	filteredTokens.reserveCapacity(tokens.size());
	for (size_t i = 0; i < tokens.size(); ++i) {
	if (!validateToken(tokens[i], exceptionState))
	return;
	if (containsInternal(AtomicString(tokens[i])))
	continue;
	if (filteredTokens.contains(tokens[i]))
	continue;
	filteredTokens.append(tokens[i]);
	}

	if (!filteredTokens.isEmpty())
	setValue(addTokens(value(), filteredTokens));
	}

	void DOMTokenList::remove(const AtomicString& token,
	ExceptionState& exceptionState) {
	Vector<String> tokens;
	tokens.append(token.getString());
	remove(tokens, exceptionState);
	}

	// Optimally, this should take a Vector<AtomicString> const ref in argument but
	// the bindings generator does not handle that.
	void DOMTokenList::remove(const Vector<String>& tokens,
	ExceptionState& exceptionState) {
	if (!validateTokens(tokens, exceptionState))
	return;

	// Check using containsInternal first since it is a lot faster than going
	// through the string character by character.
	bool found = false;
	for (size_t i = 0; i < tokens.size(); ++i) {
	if (containsInternal(AtomicString(tokens[i]))) {
	found = true;
	break;
	}
	}

	if (found)
	setValue(removeTokens(value(), tokens));
	}

	bool DOMTokenList::toggle(const AtomicString& token,
	ExceptionState& exceptionState) {
	if (!validateToken(token, exceptionState))
	return false;

	if (containsInternal(token)) {
	removeInternal(token);
	return false;
	}
	addInternal(token);
	return true;
	}

	bool DOMTokenList::toggle(const AtomicString& token,
	bool force,
	ExceptionState& exceptionState) {
	if (!validateToken(token, exceptionState))
	return false;

	if (force)
	addInternal(token);
	else
	removeInternal(token);

	return force;
	}

	bool DOMTokenList::supports(const AtomicString& token,
	ExceptionState& exceptionState) {
	return validateTokenValue(token, exceptionState);
	}

	void DOMTokenList::addInternal(const AtomicString& token) {
	if (!containsInternal(token))
	setValue(addToken(value(), token));
	}

	void DOMTokenList::removeInternal(const AtomicString& token) {
	// Check using contains first since it uses AtomicString comparisons instead
	// of character by character testing.
	if (!containsInternal(token))
	return;
	setValue(removeToken(value(), token));
	}

	AtomicString DOMTokenList::addToken(const AtomicString& input,
	const AtomicString& token) {
	Vector<String> tokens;
	tokens.append(token.getString());
	return addTokens(input, tokens);
	}

	// This returns an AtomicString because it is always passed as argument to
	// setValue() and setValue() takes an AtomicString in argument.
	AtomicString DOMTokenList::addTokens(const AtomicString& input,
	const Vector<String>& tokens) {
	bool needsSpace = false;

	StringBuilder builder;
	if (!input.isEmpty()) {
	builder.append(input);
	needsSpace = !isHTMLSpace<UChar>(input[input.length() - 1]);
	}

	for (size_t i = 0; i < tokens.size(); ++i) {
	if (needsSpace)
	builder.append(' ');
	builder.append(tokens[i]);
	needsSpace = true;
	}

	return builder.toAtomicString();
	}

	AtomicString DOMTokenList::removeToken(const AtomicString& input,
	const AtomicString& token) {
	Vector<String> tokens;
	tokens.append(token.getString());
	return removeTokens(input, tokens);
	}

	// This returns an AtomicString because it is always passed as argument to
	// setValue() and setValue() takes an AtomicString in argument.
	AtomicString DOMTokenList::removeTokens(const AtomicString& input,
	const Vector<String>& tokens) {
	// Algorithm defined at
	// http://www.whatwg.org/specs/web-apps/current-work/multipage/common-microsyntaxes.html#remove-a-token-from-a-string
	// New spec is at https://dom.spec.whatwg.org/#remove-a-token-from-a-string

	unsigned inputLength = input.length();
	StringBuilder output; // 3
	output.reserveCapacity(inputLength);
	unsigned position = 0; // 4

	// Step 5
	while (position < inputLength) {
	if (isHTMLSpace<UChar>(input[position])) { // 6
	position++;
	continue; // 6.3
	}

	// Step 7
	StringBuilder tokenBuilder;
	while (position < inputLength && isNotHTMLSpace<UChar>(input[position]))
	tokenBuilder.append(input[position++]);

	// Step 8
	String token = tokenBuilder.toString();
	if (tokens.contains(token)) {
	// Step 8.1
	while (position < inputLength && isHTMLSpace<UChar>(input[position]))
	++position;

	// Step 8.2
	size_t j = output.length();
	while (j > 0 && isHTMLSpace<UChar>(output[j - 1]))
	--j;
	output.resize(j);
	} else {
	output.append(token); // Step 9
	}

	if (position < inputLength && !output.isEmpty())
	output.append(' ');
	}

	size_t j = output.length();
	if (j > 0 && isHTMLSpace<UChar>(output[j - 1]))
	output.resize(j - 1);

	return output.toAtomicString();
	}

	void DOMTokenList::setValue(const AtomicString& value) {
	m_value = value;
	m_tokens.set(value, SpaceSplitString::ShouldNotFoldCase);
	if (m_observer)
	m_observer->valueWasSet();
	}

	bool DOMTokenList::containsInternal(const AtomicString& token) const {
	return m_tokens.contains(token);
	}

	ValueIterable<String>::IterationSource* DOMTokenList::startIteration(
	ScriptState*,
	ExceptionState&) {
	return new DOMTokenListIterationSource(this);
	}

	const AtomicString DOMTokenList::item(unsigned index) const {
	if (index >= length())
	return AtomicString();
	return m_tokens[index];
	}

	} // namespace blink