chromium/src/third_party/blink/renderer/core/html/parser/atomic_html_token.h - manifest_repos/chromium_src - Git at Google

 /*
  * Copyright (C) 2013 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. ``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
  * 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.
  */

 #ifndef THIRD_PARTY_BLINK_RENDERER_CORE_HTML_PARSER_ATOMIC_HTML_TOKEN_H_
 #define THIRD_PARTY_BLINK_RENDERER_CORE_HTML_PARSER_ATOMIC_HTML_TOKEN_H_

 #include <memory>

 #include "base/macros.h"
 #include "base/notreached.h"
 #include "third_party/blink/renderer/core/dom/attribute.h"
 #include "third_party/blink/renderer/core/html/parser/compact_html_token.h"
 #include "third_party/blink/renderer/core/html/parser/html_token.h"
 #include "third_party/blink/renderer/core/html_element_lookup_trie.h"
 #include "third_party/blink/renderer/platform/wtf/allocator/allocator.h"

 namespace blink {

 class CORE_EXPORT AtomicHTMLToken {
   STACK_ALLOCATED();

  public:
   bool ForceQuirks() const {
     DCHECK_EQ(type_, HTMLToken::DOCTYPE);
     return doctype_data_->force_quirks_;
   }

   HTMLToken::TokenType GetType() const { return type_; }

   const AtomicString& GetName() const {
     DCHECK(UsesName());
     return name_;
   }

   void SetName(const AtomicString& name) {
     DCHECK(UsesName());
     name_ = name;
   }

   bool SelfClosing() const {
     DCHECK(type_ == HTMLToken::kStartTag || type_ == HTMLToken::kEndTag);
     return self_closing_;
   }

   bool HasDuplicateAttribute() const { return duplicate_attribute_; }

   Attribute* GetAttributeItem(const QualifiedName& attribute_name) {
     DCHECK(UsesAttributes());
     return FindAttributeInVector(attributes_, attribute_name);
   }

   Vector<Attribute>& Attributes() {
     DCHECK(UsesAttributes());
     return attributes_;
   }

   const Vector<Attribute>& Attributes() const {
     DCHECK(UsesAttributes());
     return attributes_;
   }

   const String& Characters() const {
     DCHECK_EQ(type_, HTMLToken::kCharacter);
     return data_;
   }

   const String& Comment() const {
     DCHECK_EQ(type_, HTMLToken::kComment);
     return data_;
   }

   // FIXME: Distinguish between a missing public identifer and an empty one.
   Vector<UChar>& PublicIdentifier() const {
     DCHECK_EQ(type_, HTMLToken::DOCTYPE);
     return doctype_data_->public_identifier_;
   }

   // FIXME: Distinguish between a missing system identifer and an empty one.
   Vector<UChar>& SystemIdentifier() const {
     DCHECK_EQ(type_, HTMLToken::DOCTYPE);
     return doctype_data_->system_identifier_;
   }

   explicit AtomicHTMLToken(HTMLToken& token) : type_(token.GetType()) {
     switch (type_) {
       case HTMLToken::kUninitialized:
         NOTREACHED();
         break;
       case HTMLToken::DOCTYPE:
         name_ = AtomicString(token.GetName());
         doctype_data_ = token.ReleaseDoctypeData();
         break;
       case HTMLToken::kEndOfFile:
         break;
       case HTMLToken::kStartTag:
       case HTMLToken::kEndTag: {
         self_closing_ = token.SelfClosing();
         if (const AtomicString& tag_name =
                 lookupHTMLTag(token.GetName().data(), token.GetName().size()))
           name_ = tag_name;
         else
           name_ = AtomicString(token.GetName());
         InitializeAttributes(token.Attributes());
         break;
       }
       case HTMLToken::kCharacter:
       case HTMLToken::kComment:
         if (token.IsAll8BitData())
           data_ = String::Make8BitFrom16BitSource(token.Data());
         else
           data_ = String(token.Data());
         break;
     }
   }

   explicit AtomicHTMLToken(const CompactHTMLToken& token)
       : type_(token.GetType()) {
     switch (type_) {
       case HTMLToken::kUninitialized:
         NOTREACHED();
         break;
       case HTMLToken::DOCTYPE:
         name_ = AtomicString(token.Data());
         doctype_data_ = std::make_unique<DoctypeData>();
         doctype_data_->has_public_identifier_ = true;
         token.PublicIdentifier().AppendTo(doctype_data_->public_identifier_);
         doctype_data_->has_system_identifier_ = true;
         token.SystemIdentifier().AppendTo(doctype_data_->system_identifier_);
         doctype_data_->force_quirks_ = token.DoctypeForcesQuirks();
         break;
       case HTMLToken::kEndOfFile:
         break;
       case HTMLToken::kStartTag:
         attributes_.ReserveInitialCapacity(token.Attributes().size());
         for (const CompactHTMLToken::Attribute& attribute :
              token.Attributes()) {
           QualifiedName name(g_null_atom, AtomicString(attribute.GetName()),
                              g_null_atom);
           // FIXME: This is N^2 for the number of attributes.
           if (!FindAttributeInVector(attributes_, name)) {
             attributes_.push_back(
                 Attribute(name, AtomicString(attribute.Value())));
           } else {
             duplicate_attribute_ = true;
           }
         }
         FALLTHROUGH;
       case HTMLToken::kEndTag:
         self_closing_ = token.SelfClosing();
         name_ = AtomicString(token.Data());
         break;
       case HTMLToken::kCharacter:
       case HTMLToken::kComment:
         data_ = token.Data();
         break;
     }
   }

   explicit AtomicHTMLToken(HTMLToken::TokenType type) : type_(type) {}

   AtomicHTMLToken(HTMLToken::TokenType type,
                   const AtomicString& name,
                   const Vector<Attribute>& attributes = Vector<Attribute>())
       : type_(type),
         name_(name),
         attributes_(attributes) {
     DCHECK(UsesName());
   }

 #ifndef NDEBUG
   void Show() const;
 #endif

  private:
   HTMLToken::TokenType type_;

   void InitializeAttributes(const HTMLToken::AttributeList& attributes);
   QualifiedName NameForAttribute(const HTMLToken::Attribute&) const;

   bool UsesName() const;

   bool UsesAttributes() const;

   // "name" for DOCTYPE, StartTag, and EndTag
   AtomicString name_;

   // "data" for Comment, "characters" for Character
   String data_;

   // For DOCTYPE
   std::unique_ptr<DoctypeData> doctype_data_;

   // For StartTag and EndTag
   bool self_closing_ = false;

   bool duplicate_attribute_ = false;

   Vector<Attribute> attributes_;

   DISALLOW_COPY_AND_ASSIGN(AtomicHTMLToken);
 };

 inline void AtomicHTMLToken::InitializeAttributes(
     const HTMLToken::AttributeList& attributes) {
   wtf_size_t size = attributes.size();
   if (!size)
     return;

   attributes_.clear();
   attributes_.ReserveInitialCapacity(size);
   for (const auto& attribute : attributes) {
     if (attribute.NameAsVector().IsEmpty())
       continue;

     attribute.NameRange().CheckValid();
     attribute.ValueRange().CheckValid();

     AtomicString value(attribute.ValueAsVector());
     // attribute.ValueAsVector.data() is null for attributes with no values, but
     // the null atom is used to represent absence of attributes; attributes with
     // no values have the value set to an empty atom instead.
     if (value == g_null_atom) {
       value = g_empty_atom;
     }
     const QualifiedName& name = NameForAttribute(attribute);
     // FIXME: This is N^2 for the number of attributes.
     if (!FindAttributeInVector(attributes_, name)) {
       attributes_.push_back(Attribute(name, value));
     } else {
       duplicate_attribute_ = true;
     }
   }
 }

 }  // namespace blink

 #endif
	/*
	* Copyright (C) 2013 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. ``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
	* 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.
	*/

	#ifndef THIRD_PARTY_BLINK_RENDERER_CORE_HTML_PARSER_ATOMIC_HTML_TOKEN_H_
	#define THIRD_PARTY_BLINK_RENDERER_CORE_HTML_PARSER_ATOMIC_HTML_TOKEN_H_

	#include <memory>

	#include "base/macros.h"
	#include "base/notreached.h"
	#include "third_party/blink/renderer/core/dom/attribute.h"
	#include "third_party/blink/renderer/core/html/parser/compact_html_token.h"
	#include "third_party/blink/renderer/core/html/parser/html_token.h"
	#include "third_party/blink/renderer/core/html_element_lookup_trie.h"
	#include "third_party/blink/renderer/platform/wtf/allocator/allocator.h"

	namespace blink {

	class CORE_EXPORT AtomicHTMLToken {
	STACK_ALLOCATED();

	public:
	bool ForceQuirks() const {
	DCHECK_EQ(type_, HTMLToken::DOCTYPE);
	return doctype_data_->force_quirks_;
	}

	HTMLToken::TokenType GetType() const { return type_; }

	const AtomicString& GetName() const {
	DCHECK(UsesName());
	return name_;
	}

	void SetName(const AtomicString& name) {
	DCHECK(UsesName());
	name_ = name;
	}

	bool SelfClosing() const {
	DCHECK(type_ == HTMLToken::kStartTag \|\| type_ == HTMLToken::kEndTag);
	return self_closing_;
	}

	bool HasDuplicateAttribute() const { return duplicate_attribute_; }

	Attribute* GetAttributeItem(const QualifiedName& attribute_name) {
	DCHECK(UsesAttributes());
	return FindAttributeInVector(attributes_, attribute_name);
	}

	Vector<Attribute>& Attributes() {
	DCHECK(UsesAttributes());
	return attributes_;
	}

	const Vector<Attribute>& Attributes() const {
	DCHECK(UsesAttributes());
	return attributes_;
	}

	const String& Characters() const {
	DCHECK_EQ(type_, HTMLToken::kCharacter);
	return data_;
	}

	const String& Comment() const {
	DCHECK_EQ(type_, HTMLToken::kComment);
	return data_;
	}

	// FIXME: Distinguish between a missing public identifer and an empty one.
	Vector<UChar>& PublicIdentifier() const {
	DCHECK_EQ(type_, HTMLToken::DOCTYPE);
	return doctype_data_->public_identifier_;
	}

	// FIXME: Distinguish between a missing system identifer and an empty one.
	Vector<UChar>& SystemIdentifier() const {
	DCHECK_EQ(type_, HTMLToken::DOCTYPE);
	return doctype_data_->system_identifier_;
	}

	explicit AtomicHTMLToken(HTMLToken& token) : type_(token.GetType()) {
	switch (type_) {
	case HTMLToken::kUninitialized:
	NOTREACHED();
	break;
	case HTMLToken::DOCTYPE:
	name_ = AtomicString(token.GetName());
	doctype_data_ = token.ReleaseDoctypeData();
	break;
	case HTMLToken::kEndOfFile:
	break;
	case HTMLToken::kStartTag:
	case HTMLToken::kEndTag: {
	self_closing_ = token.SelfClosing();
	if (const AtomicString& tag_name =
	lookupHTMLTag(token.GetName().data(), token.GetName().size()))
	name_ = tag_name;
	else
	name_ = AtomicString(token.GetName());
	InitializeAttributes(token.Attributes());
	break;
	}
	case HTMLToken::kCharacter:
	case HTMLToken::kComment:
	if (token.IsAll8BitData())
	data_ = String::Make8BitFrom16BitSource(token.Data());
	else
	data_ = String(token.Data());
	break;
	}
	}

	explicit AtomicHTMLToken(const CompactHTMLToken& token)
	: type_(token.GetType()) {
	switch (type_) {
	case HTMLToken::kUninitialized:
	NOTREACHED();
	break;
	case HTMLToken::DOCTYPE:
	name_ = AtomicString(token.Data());
	doctype_data_ = std::make_unique<DoctypeData>();
	doctype_data_->has_public_identifier_ = true;
	token.PublicIdentifier().AppendTo(doctype_data_->public_identifier_);
	doctype_data_->has_system_identifier_ = true;
	token.SystemIdentifier().AppendTo(doctype_data_->system_identifier_);
	doctype_data_->force_quirks_ = token.DoctypeForcesQuirks();
	break;
	case HTMLToken::kEndOfFile:
	break;
	case HTMLToken::kStartTag:
	attributes_.ReserveInitialCapacity(token.Attributes().size());
	for (const CompactHTMLToken::Attribute& attribute :
	token.Attributes()) {
	QualifiedName name(g_null_atom, AtomicString(attribute.GetName()),
	g_null_atom);
	// FIXME: This is N^2 for the number of attributes.
	if (!FindAttributeInVector(attributes_, name)) {
	attributes_.push_back(
	Attribute(name, AtomicString(attribute.Value())));
	} else {
	duplicate_attribute_ = true;
	}
	}
	FALLTHROUGH;
	case HTMLToken::kEndTag:
	self_closing_ = token.SelfClosing();
	name_ = AtomicString(token.Data());
	break;
	case HTMLToken::kCharacter:
	case HTMLToken::kComment:
	data_ = token.Data();
	break;
	}
	}

	explicit AtomicHTMLToken(HTMLToken::TokenType type) : type_(type) {}

	AtomicHTMLToken(HTMLToken::TokenType type,
	const AtomicString& name,
	const Vector<Attribute>& attributes = Vector<Attribute>())
	: type_(type),
	name_(name),
	attributes_(attributes) {
	DCHECK(UsesName());
	}

	#ifndef NDEBUG
	void Show() const;
	#endif

	private:
	HTMLToken::TokenType type_;

	void InitializeAttributes(const HTMLToken::AttributeList& attributes);
	QualifiedName NameForAttribute(const HTMLToken::Attribute&) const;

	bool UsesName() const;

	bool UsesAttributes() const;

	// "name" for DOCTYPE, StartTag, and EndTag
	AtomicString name_;

	// "data" for Comment, "characters" for Character
	String data_;

	// For DOCTYPE
	std::unique_ptr<DoctypeData> doctype_data_;

	// For StartTag and EndTag
	bool self_closing_ = false;

	bool duplicate_attribute_ = false;

	Vector<Attribute> attributes_;

	DISALLOW_COPY_AND_ASSIGN(AtomicHTMLToken);
	};

	inline void AtomicHTMLToken::InitializeAttributes(
	const HTMLToken::AttributeList& attributes) {
	wtf_size_t size = attributes.size();
	if (!size)
	return;

	attributes_.clear();
	attributes_.ReserveInitialCapacity(size);
	for (const auto& attribute : attributes) {
	if (attribute.NameAsVector().IsEmpty())
	continue;

	attribute.NameRange().CheckValid();
	attribute.ValueRange().CheckValid();

	AtomicString value(attribute.ValueAsVector());
	// attribute.ValueAsVector.data() is null for attributes with no values, but
	// the null atom is used to represent absence of attributes; attributes with
	// no values have the value set to an empty atom instead.
	if (value == g_null_atom) {
	value = g_empty_atom;
	}
	const QualifiedName& name = NameForAttribute(attribute);
	// FIXME: This is N^2 for the number of attributes.
	if (!FindAttributeInVector(attributes_, name)) {
	attributes_.push_back(Attribute(name, value));
	} else {
	duplicate_attribute_ = true;
	}
	}
	}

	} // namespace blink

	#endif