Migrate WTF::Vector::append() to ::push_back() [part 7 of N]

third_party/WebKit/Source/core/html/parser/HTMLToken.h

 /*
  * 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
@@ skipping 98 matching lines @@
       int start;
       int end;
     };
 
     AtomicString name() const { return AtomicString(m_name); }
     String nameAttemptStaticStringCreation() const {
       return attemptStaticStringCreation(m_name, Likely8Bit);
     }
     const Vector<UChar, 32>& nameAsVector() const { return m_name; }
 
-    void appendToName(UChar c) { m_name.append(c); }
+    void appendToName(UChar c) { m_name.push_back(c); }
 
     PassRefPtr<StringImpl> value8BitIfNecessary() const {
       return StringImpl::create8BitIfPossible(m_value);
     }
     String value() const { return String(m_value); }
 
-    void appendToValue(UChar c) { m_value.append(c); }
+    void appendToValue(UChar c) { m_value.push_back(c); }
     void appendToValue(const String& value) { value.appendTo(m_value); }
     void clearValue() { m_value.clear(); }
 
     const Range& nameRange() const { return m_nameRange; }
     const Range& valueRange() const { return m_valueRange; }
     Range& mutableNameRange() { return m_nameRange; }
     Range& mutableValueRange() { return m_valueRange; }
 
    private:
     Vector<UChar, 32> m_name;
@@ skipping 51 matching lines @@
   bool isAll8BitData() const { return (m_orAllData <= 0xff); }
 
   const DataVector& name() const {
     ASSERT(m_type == StartTag || m_type == EndTag || m_type == DOCTYPE);
     return m_data;
   }
 
   void appendToName(UChar character) {
     ASSERT(m_type == StartTag || m_type == EndTag || m_type == DOCTYPE);
     ASSERT(character);
-    m_data.append(character);
+    m_data.push_back(character);
     m_orAllData |= character;
   }
 
   /* DOCTYPE Tokens */
 
   bool forceQuirks() const {
     ASSERT(m_type == DOCTYPE);
     return m_doctypeData->m_forceQuirks;
   }
 
   void setForceQuirks() {
     ASSERT(m_type == DOCTYPE);
     m_doctypeData->m_forceQuirks = true;
   }
 
   void beginDOCTYPE() {
     ASSERT(m_type == Uninitialized);
     m_type = DOCTYPE;
     m_doctypeData = WTF::wrapUnique(new DoctypeData);
   }
 
   void beginDOCTYPE(UChar character) {
     ASSERT(character);
     beginDOCTYPE();
-    m_data.append(character);
+    m_data.push_back(character);
     m_orAllData |= character;
   }
 
   // FIXME: Distinguish between a missing public identifer and an empty one.
   const WTF::Vector<UChar>& publicIdentifier() const {
     ASSERT(m_type == DOCTYPE);
     return m_doctypeData->m_publicIdentifier;
   }
 
   // FIXME: Distinguish between a missing system identifer and an empty one.
@@ skipping 11 matching lines @@
   void setSystemIdentifierToEmptyString() {
     ASSERT(m_type == DOCTYPE);
     m_doctypeData->m_hasSystemIdentifier = true;
     m_doctypeData->m_systemIdentifier.clear();
   }
 
   void appendToPublicIdentifier(UChar character) {
     ASSERT(character);
     ASSERT(m_type == DOCTYPE);
     ASSERT(m_doctypeData->m_hasPublicIdentifier);
-    m_doctypeData->m_publicIdentifier.append(character);
+    m_doctypeData->m_publicIdentifier.push_back(character);
   }
 
   void appendToSystemIdentifier(UChar character) {
     ASSERT(character);
     ASSERT(m_type == DOCTYPE);
     ASSERT(m_doctypeData->m_hasSystemIdentifier);
-    m_doctypeData->m_systemIdentifier.append(character);
+    m_doctypeData->m_systemIdentifier.push_back(character);
   }
 
   std::unique_ptr<DoctypeData> releaseDoctypeData() {
     return std::move(m_doctypeData);
   }
 
   /* Start/End Tag Tokens */
 
   bool selfClosing() const {
     ASSERT(m_type == StartTag || m_type == EndTag);
     return m_selfClosing;
   }
 
   void setSelfClosing() {
     ASSERT(m_type == StartTag || m_type == EndTag);
     m_selfClosing = true;
   }
 
   void beginStartTag(UChar character) {
     ASSERT(character);
     ASSERT(m_type == Uninitialized);
     m_type = StartTag;
     m_selfClosing = false;
     m_currentAttribute = 0;
     m_attributes.clear();
 
-    m_data.append(character);
+    m_data.push_back(character);
     m_orAllData |= character;
   }
 
   void beginEndTag(LChar character) {
     ASSERT(m_type == Uninitialized);
     m_type = EndTag;
     m_selfClosing = false;
     m_currentAttribute = 0;
     m_attributes.clear();
 
-    m_data.append(character);
+    m_data.push_back(character);
   }
 
   void beginEndTag(const Vector<LChar, 32>& characters) {
     ASSERT(m_type == Uninitialized);
     m_type = EndTag;
     m_selfClosing = false;
     m_currentAttribute = 0;
     m_attributes.clear();
 
     m_data.appendVector(characters);
@@ skipping 79 matching lines @@
     m_type = Character;
   }
 
   const DataVector& characters() const {
     ASSERT(m_type == Character);
     return m_data;
   }
 
   void appendToCharacter(char character) {
     ASSERT(m_type == Character);
-    m_data.append(character);
+    m_data.push_back(character);
   }
 
   void appendToCharacter(UChar character) {
     ASSERT(m_type == Character);
-    m_data.append(character);
+    m_data.push_back(character);
     m_orAllData |= character;
   }
 
   void appendToCharacter(const Vector<LChar, 32>& characters) {
     ASSERT(m_type == Character);
     m_data.appendVector(characters);
   }
 
   /* Comment Tokens */
 
   const DataVector& comment() const {
     ASSERT(m_type == Comment);
     return m_data;
   }
 
   void beginComment() {
     ASSERT(m_type == Uninitialized);
     m_type = Comment;
   }
 
   void appendToComment(UChar character) {
     ASSERT(character);
     ASSERT(m_type == Comment);
-    m_data.append(character);
+    m_data.push_back(character);
     m_orAllData |= character;
   }
 
   // Only for XSSAuditor
   void eraseCharacters() {
     ASSERT(m_type == Character);
     m_data.clear();
     m_orAllData = 0;
   }
 
@@ skipping 15 matching lines @@
   std::unique_ptr<DoctypeData> m_doctypeData;
 };
 
 #ifndef NDEBUG
 const char* toString(HTMLToken::TokenType);
 #endif
 
 }  // namespace blink
 
 #endif