HTMLTokenizer: Fold isASCIIUpper() / isASCIILower() cases

third_party/WebKit/Source/core/html/parser/HTMLTokenizer.cpp

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  * Copyright (C) 2009 Torch Mobile, Inc. http://www.torchmobile.com/
  * 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.
@@ skipping 27 matching lines @@
 
 // Please don't use DEFINE_STATIC_LOCAL in this file. The HTMLTokenizer is used
 // from multiple threads and DEFINE_STATIC_LOCAL isn't threadsafe.
 #undef DEFINE_STATIC_LOCAL
 
 namespace blink {
 
 using namespace HTMLNames;
 
 static inline UChar ToLowerCase(UChar cc) {
-  DCHECK(IsASCIIUpper(cc));
-  const int kLowerCaseOffset = 0x20;
-  return cc + kLowerCaseOffset;
+  DCHECK(IsASCIIAlpha(cc));
+  return cc | 0x20;
+}
+
+static inline UChar ToLowerCaseIfAlpha(UChar cc) {
+  return cc | (IsASCIIUpper(cc) ? 0x20 : 0);
 }
 
 static inline bool VectorEqualsString(const Vector<LChar, 32>& vector,
                                       const String& string) {
   if (vector.size() != string.length())
     return false;
 
   if (!string.length())
     return true;
 
@@ skipping 167 matching lines @@
 
     HTML_BEGIN_STATE(kPLAINTEXTState) {
       if (cc == kEndOfFileMarker)
         return EmitEndOfFile(source);
       BufferCharacter(cc);
       HTML_ADVANCE_TO(kPLAINTEXTState);
     }
     END_STATE()
 
     HTML_BEGIN_STATE(kTagOpenState) {
-      if (cc == '!')
+      if (cc == '!') {
         HTML_ADVANCE_TO(kMarkupDeclarationOpenState);
-      else if (cc == '/')
+      } else if (cc == '/') {
         HTML_ADVANCE_TO(kEndTagOpenState);
-      else if (IsASCIIUpper(cc)) {
+      } else if (IsASCIIAlpha(cc)) {
         token_->BeginStartTag(ToLowerCase(cc));
         HTML_ADVANCE_TO(kTagNameState);
-      } else if (IsASCIILower(cc)) {
-        token_->BeginStartTag(cc);
-        HTML_ADVANCE_TO(kTagNameState);
       } else if (cc == '?') {
         ParseError();
         // The spec consumes the current character before switching
         // to the bogus comment state, but it's easier to implement
         // if we reconsume the current character.
         HTML_RECONSUME_IN(kBogusCommentState);
       } else {
         ParseError();
         BufferCharacter('<');
         HTML_RECONSUME_IN(kDataState);
       }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(kEndTagOpenState) {
-      if (IsASCIIUpper(cc)) {
+      if (IsASCIIAlpha(cc)) {
         token_->BeginEndTag(static_cast<LChar>(ToLowerCase(cc)));
         appropriate_end_tag_name_.clear();
         HTML_ADVANCE_TO(kTagNameState);
-      } else if (IsASCIILower(cc)) {
-        token_->BeginEndTag(static_cast<LChar>(cc));
-        appropriate_end_tag_name_.clear();
-        HTML_ADVANCE_TO(kTagNameState);
       } else if (cc == '>') {
         ParseError();
         HTML_ADVANCE_TO(kDataState);
       } else if (cc == kEndOfFileMarker) {
         ParseError();
         BufferCharacter('<');
         BufferCharacter('/');
         HTML_RECONSUME_IN(kDataState);
       } else {
         ParseError();
         HTML_RECONSUME_IN(kBogusCommentState);
       }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(kTagNameState) {
-      if (IsTokenizerWhitespace(cc))
+      if (IsTokenizerWhitespace(cc)) {
         HTML_ADVANCE_TO(kBeforeAttributeNameState);
-      else if (cc == '/')
+      } else if (cc == '/') {
         HTML_ADVANCE_TO(kSelfClosingStartTagState);
-      else if (cc == '>')
+      } else if (cc == '>') {
         return EmitAndResumeIn(source, HTMLTokenizer::kDataState);
-      else if (IsASCIIUpper(cc)) {
-        token_->AppendToName(ToLowerCase(cc));
-        HTML_ADVANCE_TO(kTagNameState);
       } else if (cc == kEndOfFileMarker) {
         ParseError();
         HTML_RECONSUME_IN(kDataState);
       } else {
-        token_->AppendToName(cc);
+        token_->AppendToName(ToLowerCaseIfAlpha(cc));
         HTML_ADVANCE_TO(kTagNameState);
       }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(kRCDATALessThanSignState) {
       if (cc == '/') {
         temporary_buffer_.clear();
         DCHECK(buffered_end_tag_name_.IsEmpty());
         HTML_ADVANCE_TO(kRCDATAEndTagOpenState);
       } else {
         BufferCharacter('<');
         HTML_RECONSUME_IN(kRCDATAState);
       }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(kRCDATAEndTagOpenState) {
-      if (IsASCIIUpper(cc)) {
+      if (IsASCIIAlpha(cc)) {
         temporary_buffer_.push_back(static_cast<LChar>(cc));
         AddToPossibleEndTag(static_cast<LChar>(ToLowerCase(cc)));
         HTML_ADVANCE_TO(kRCDATAEndTagNameState);
-      } else if (IsASCIILower(cc)) {
-        temporary_buffer_.push_back(static_cast<LChar>(cc));
-        AddToPossibleEndTag(static_cast<LChar>(cc));
-        HTML_ADVANCE_TO(kRCDATAEndTagNameState);
       } else {
         BufferCharacter('<');
         BufferCharacter('/');
         HTML_RECONSUME_IN(kRCDATAState);
       }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(kRCDATAEndTagNameState) {
-      if (IsASCIIUpper(cc)) {
+      if (IsASCIIAlpha(cc)) {
         temporary_buffer_.push_back(static_cast<LChar>(cc));
         AddToPossibleEndTag(static_cast<LChar>(ToLowerCase(cc)));
         HTML_ADVANCE_TO(kRCDATAEndTagNameState);
-      } else if (IsASCIILower(cc)) {
-        temporary_buffer_.push_back(static_cast<LChar>(cc));
-        AddToPossibleEndTag(static_cast<LChar>(cc));
-        HTML_ADVANCE_TO(kRCDATAEndTagNameState);
       } else {
         if (IsTokenizerWhitespace(cc)) {
           if (IsAppropriateEndTag()) {
             temporary_buffer_.push_back(static_cast<LChar>(cc));
             FLUSH_AND_ADVANCE_TO(kBeforeAttributeNameState);
           }
         } else if (cc == '/') {
           if (IsAppropriateEndTag()) {
             temporary_buffer_.push_back(static_cast<LChar>(cc));
             FLUSH_AND_ADVANCE_TO(kSelfClosingStartTagState);
@@ skipping 20 matching lines @@
         DCHECK(buffered_end_tag_name_.IsEmpty());
         HTML_ADVANCE_TO(kRAWTEXTEndTagOpenState);
       } else {
         BufferCharacter('<');
         HTML_RECONSUME_IN(kRAWTEXTState);
       }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(kRAWTEXTEndTagOpenState) {
-      if (IsASCIIUpper(cc)) {
+      if (IsASCIIAlpha(cc)) {
         temporary_buffer_.push_back(static_cast<LChar>(cc));
         AddToPossibleEndTag(static_cast<LChar>(ToLowerCase(cc)));
         HTML_ADVANCE_TO(kRAWTEXTEndTagNameState);
-      } else if (IsASCIILower(cc)) {
-        temporary_buffer_.push_back(static_cast<LChar>(cc));
-        AddToPossibleEndTag(static_cast<LChar>(cc));
-        HTML_ADVANCE_TO(kRAWTEXTEndTagNameState);
       } else {
         BufferCharacter('<');
         BufferCharacter('/');
         HTML_RECONSUME_IN(kRAWTEXTState);
       }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(kRAWTEXTEndTagNameState) {
-      if (IsASCIIUpper(cc)) {
+      if (IsASCIIAlpha(cc)) {
         temporary_buffer_.push_back(static_cast<LChar>(cc));
         AddToPossibleEndTag(static_cast<LChar>(ToLowerCase(cc)));
         HTML_ADVANCE_TO(kRAWTEXTEndTagNameState);
-      } else if (IsASCIILower(cc)) {
-        temporary_buffer_.push_back(static_cast<LChar>(cc));
-        AddToPossibleEndTag(static_cast<LChar>(cc));
-        HTML_ADVANCE_TO(kRAWTEXTEndTagNameState);
       } else {
         if (IsTokenizerWhitespace(cc)) {
           if (IsAppropriateEndTag()) {
             temporary_buffer_.push_back(static_cast<LChar>(cc));
             FLUSH_AND_ADVANCE_TO(kBeforeAttributeNameState);
           }
         } else if (cc == '/') {
           if (IsAppropriateEndTag()) {
             temporary_buffer_.push_back(static_cast<LChar>(cc));
             FLUSH_AND_ADVANCE_TO(kSelfClosingStartTagState);
@@ skipping 24 matching lines @@
         BufferCharacter('!');
         HTML_ADVANCE_TO(kScriptDataEscapeStartState);
       } else {
         BufferCharacter('<');
         HTML_RECONSUME_IN(kScriptDataState);
       }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(kScriptDataEndTagOpenState) {
-      if (IsASCIIUpper(cc)) {
+      if (IsASCIIAlpha(cc)) {
         temporary_buffer_.push_back(static_cast<LChar>(cc));
         AddToPossibleEndTag(static_cast<LChar>(ToLowerCase(cc)));
         HTML_ADVANCE_TO(kScriptDataEndTagNameState);
-      } else if (IsASCIILower(cc)) {
-        temporary_buffer_.push_back(static_cast<LChar>(cc));
-        AddToPossibleEndTag(static_cast<LChar>(cc));
-        HTML_ADVANCE_TO(kScriptDataEndTagNameState);
       } else {
         BufferCharacter('<');
         BufferCharacter('/');
         HTML_RECONSUME_IN(kScriptDataState);
       }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(kScriptDataEndTagNameState) {
-      if (IsASCIIUpper(cc)) {
+      if (IsASCIIAlpha(cc)) {
         temporary_buffer_.push_back(static_cast<LChar>(cc));
         AddToPossibleEndTag(static_cast<LChar>(ToLowerCase(cc)));
         HTML_ADVANCE_TO(kScriptDataEndTagNameState);
-      } else if (IsASCIILower(cc)) {
-        temporary_buffer_.push_back(static_cast<LChar>(cc));
-        AddToPossibleEndTag(static_cast<LChar>(cc));
-        HTML_ADVANCE_TO(kScriptDataEndTagNameState);
       } else {
         if (IsTokenizerWhitespace(cc)) {
           if (IsAppropriateEndTag()) {
             temporary_buffer_.push_back(static_cast<LChar>(cc));
             FLUSH_AND_ADVANCE_TO(kBeforeAttributeNameState);
           }
         } else if (cc == '/') {
           if (IsAppropriateEndTag()) {
             temporary_buffer_.push_back(static_cast<LChar>(cc));
             FLUSH_AND_ADVANCE_TO(kSelfClosingStartTagState);
@@ skipping 81 matching lines @@
         HTML_ADVANCE_TO(kScriptDataEscapedState);
       }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(kScriptDataEscapedLessThanSignState) {
       if (cc == '/') {
         temporary_buffer_.clear();
         DCHECK(buffered_end_tag_name_.IsEmpty());
         HTML_ADVANCE_TO(kScriptDataEscapedEndTagOpenState);
-      } else if (IsASCIIUpper(cc)) {
+      } else if (IsASCIIAlpha(cc)) {
         BufferCharacter('<');
         BufferCharacter(cc);
         temporary_buffer_.clear();
-        temporary_buffer_.push_back(ToLowerCase(cc));
-        HTML_ADVANCE_TO(kScriptDataDoubleEscapeStartState);
-      } else if (IsASCIILower(cc)) {
-        BufferCharacter('<');
-        BufferCharacter(cc);
-        temporary_buffer_.clear();
-        temporary_buffer_.push_back(static_cast<LChar>(cc));
+        temporary_buffer_.push_back(static_cast<LChar>(ToLowerCase(cc)));
         HTML_ADVANCE_TO(kScriptDataDoubleEscapeStartState);
       } else {
         BufferCharacter('<');
         HTML_RECONSUME_IN(kScriptDataEscapedState);
       }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(kScriptDataEscapedEndTagOpenState) {
-      if (IsASCIIUpper(cc)) {
+      if (IsASCIIAlpha(cc)) {
         temporary_buffer_.push_back(static_cast<LChar>(cc));
         AddToPossibleEndTag(static_cast<LChar>(ToLowerCase(cc)));
         HTML_ADVANCE_TO(kScriptDataEscapedEndTagNameState);
-      } else if (IsASCIILower(cc)) {
-        temporary_buffer_.push_back(static_cast<LChar>(cc));
-        AddToPossibleEndTag(static_cast<LChar>(cc));
-        HTML_ADVANCE_TO(kScriptDataEscapedEndTagNameState);
       } else {
         BufferCharacter('<');
         BufferCharacter('/');
         HTML_RECONSUME_IN(kScriptDataEscapedState);
       }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(kScriptDataEscapedEndTagNameState) {
-      if (IsASCIIUpper(cc)) {
+      if (IsASCIIAlpha(cc)) {
         temporary_buffer_.push_back(static_cast<LChar>(cc));
         AddToPossibleEndTag(static_cast<LChar>(ToLowerCase(cc)));
         HTML_ADVANCE_TO(kScriptDataEscapedEndTagNameState);
-      } else if (IsASCIILower(cc)) {
-        temporary_buffer_.push_back(static_cast<LChar>(cc));
-        AddToPossibleEndTag(static_cast<LChar>(cc));
-        HTML_ADVANCE_TO(kScriptDataEscapedEndTagNameState);
       } else {
         if (IsTokenizerWhitespace(cc)) {
           if (IsAppropriateEndTag()) {
             temporary_buffer_.push_back(static_cast<LChar>(cc));
             FLUSH_AND_ADVANCE_TO(kBeforeAttributeNameState);
           }
         } else if (cc == '/') {
           if (IsAppropriateEndTag()) {
             temporary_buffer_.push_back(static_cast<LChar>(cc));
             FLUSH_AND_ADVANCE_TO(kSelfClosingStartTagState);
@@ skipping 14 matching lines @@
     }
     END_STATE()
 
     HTML_BEGIN_STATE(kScriptDataDoubleEscapeStartState) {
       if (IsTokenizerWhitespace(cc) || cc == '/' || cc == '>') {
         BufferCharacter(cc);
         if (TemporaryBufferIs(scriptTag.LocalName()))
           HTML_ADVANCE_TO(kScriptDataDoubleEscapedState);
         else
           HTML_ADVANCE_TO(kScriptDataEscapedState);
-      } else if (IsASCIIUpper(cc)) {
+      } else if (IsASCIIAlpha(cc)) {
         BufferCharacter(cc);
-        temporary_buffer_.push_back(ToLowerCase(cc));
-        HTML_ADVANCE_TO(kScriptDataDoubleEscapeStartState);
-      } else if (IsASCIILower(cc)) {
-        BufferCharacter(cc);
-        temporary_buffer_.push_back(static_cast<LChar>(cc));
+        temporary_buffer_.push_back(static_cast<LChar>(ToLowerCase(cc)));
         HTML_ADVANCE_TO(kScriptDataDoubleEscapeStartState);
       } else
         HTML_RECONSUME_IN(kScriptDataEscapedState);
     }
     END_STATE()
 
     HTML_BEGIN_STATE(kScriptDataDoubleEscapedState) {
       if (cc == '-') {
         BufferCharacter(cc);
         HTML_ADVANCE_TO(kScriptDataDoubleEscapedDashState);
@@ skipping 57 matching lines @@
     }
     END_STATE()
 
     HTML_BEGIN_STATE(kScriptDataDoubleEscapeEndState) {
       if (IsTokenizerWhitespace(cc) || cc == '/' || cc == '>') {
         BufferCharacter(cc);
         if (TemporaryBufferIs(scriptTag.LocalName()))
           HTML_ADVANCE_TO(kScriptDataEscapedState);
         else
           HTML_ADVANCE_TO(kScriptDataDoubleEscapedState);
-      } else if (IsASCIIUpper(cc)) {
+      } else if (IsASCIIAlpha(cc)) {
         BufferCharacter(cc);
-        temporary_buffer_.push_back(ToLowerCase(cc));
-        HTML_ADVANCE_TO(kScriptDataDoubleEscapeEndState);
-      } else if (IsASCIILower(cc)) {
-        BufferCharacter(cc);
-        temporary_buffer_.push_back(static_cast<LChar>(cc));
+        temporary_buffer_.push_back(static_cast<LChar>(ToLowerCase(cc)));
         HTML_ADVANCE_TO(kScriptDataDoubleEscapeEndState);
       } else
         HTML_RECONSUME_IN(kScriptDataDoubleEscapedState);
     }
     END_STATE()
 
     HTML_BEGIN_STATE(kBeforeAttributeNameState) {
-      if (IsTokenizerWhitespace(cc))
+      if (IsTokenizerWhitespace(cc)) {
         HTML_ADVANCE_TO(kBeforeAttributeNameState);
-      else if (cc == '/')
+      } else if (cc == '/') {
         HTML_ADVANCE_TO(kSelfClosingStartTagState);
-      else if (cc == '>')
+      } else if (cc == '>') {
         return EmitAndResumeIn(source, HTMLTokenizer::kDataState);
-      else if (IsASCIIUpper(cc)) {
-        token_->AddNewAttribute();
-        token_->BeginAttributeName(source.NumberOfCharactersConsumed());
-        token_->AppendToAttributeName(ToLowerCase(cc));
-        HTML_ADVANCE_TO(kAttributeNameState);
       } else if (cc == kEndOfFileMarker) {
         ParseError();
         HTML_RECONSUME_IN(kDataState);
       } else {
         if (cc == '"' || cc == '\'' || cc == '<' || cc == '=')
           ParseError();
         token_->AddNewAttribute();
         token_->BeginAttributeName(source.NumberOfCharactersConsumed());
-        token_->AppendToAttributeName(cc);
+        token_->AppendToAttributeName(ToLowerCaseIfAlpha(cc));
         HTML_ADVANCE_TO(kAttributeNameState);
       }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(kAttributeNameState) {
       if (IsTokenizerWhitespace(cc)) {
         token_->EndAttributeName(source.NumberOfCharactersConsumed());
         HTML_ADVANCE_TO(kAfterAttributeNameState);
       } else if (cc == '/') {
         token_->EndAttributeName(source.NumberOfCharactersConsumed());
         HTML_ADVANCE_TO(kSelfClosingStartTagState);
       } else if (cc == '=') {
         token_->EndAttributeName(source.NumberOfCharactersConsumed());
         HTML_ADVANCE_TO(kBeforeAttributeValueState);
       } else if (cc == '>') {
         token_->EndAttributeName(source.NumberOfCharactersConsumed());
         return EmitAndResumeIn(source, HTMLTokenizer::kDataState);
-      } else if (IsASCIIUpper(cc)) {
-        token_->AppendToAttributeName(ToLowerCase(cc));
-        HTML_ADVANCE_TO(kAttributeNameState);
       } else if (cc == kEndOfFileMarker) {
         ParseError();
         token_->EndAttributeName(source.NumberOfCharactersConsumed());
         HTML_RECONSUME_IN(kDataState);
       } else {
         if (cc == '"' || cc == '\'' || cc == '<' || cc == '=')
           ParseError();
-        token_->AppendToAttributeName(cc);
+        token_->AppendToAttributeName(ToLowerCaseIfAlpha(cc));
         HTML_ADVANCE_TO(kAttributeNameState);
       }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(kAfterAttributeNameState) {
-      if (IsTokenizerWhitespace(cc))
+      if (IsTokenizerWhitespace(cc)) {
         HTML_ADVANCE_TO(kAfterAttributeNameState);
-      else if (cc == '/')
+      } else if (cc == '/') {
         HTML_ADVANCE_TO(kSelfClosingStartTagState);
-      else if (cc == '=')
+      } else if (cc == '=') {
         HTML_ADVANCE_TO(kBeforeAttributeValueState);
-      else if (cc == '>')
+      } else if (cc == '>') {
         return EmitAndResumeIn(source, HTMLTokenizer::kDataState);
-      else if (IsASCIIUpper(cc)) {
-        token_->AddNewAttribute();
-        token_->BeginAttributeName(source.NumberOfCharactersConsumed());
-        token_->AppendToAttributeName(ToLowerCase(cc));
-        HTML_ADVANCE_TO(kAttributeNameState);
       } else if (cc == kEndOfFileMarker) {
         ParseError();
         HTML_RECONSUME_IN(kDataState);
       } else {
         if (cc == '"' || cc == '\'' || cc == '<')
           ParseError();
         token_->AddNewAttribute();
         token_->BeginAttributeName(source.NumberOfCharactersConsumed());
-        token_->AppendToAttributeName(cc);
+        token_->AppendToAttributeName(ToLowerCaseIfAlpha(cc));
         HTML_ADVANCE_TO(kAttributeNameState);
       }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(kBeforeAttributeValueState) {
       if (IsTokenizerWhitespace(cc))
         HTML_ADVANCE_TO(kBeforeAttributeValueState);
       else if (cc == '"') {
         token_->BeginAttributeValue(source.NumberOfCharactersConsumed() + 1);
@@ skipping 304 matching lines @@
         token_->SetForceQuirks();
         return EmitAndReconsumeIn(source, HTMLTokenizer::kDataState);
       } else {
         ParseError();
         HTML_RECONSUME_IN(kBeforeDOCTYPENameState);
       }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(kBeforeDOCTYPENameState) {
-      if (IsTokenizerWhitespace(cc))
+      if (IsTokenizerWhitespace(cc)) {
         HTML_ADVANCE_TO(kBeforeDOCTYPENameState);
-      else if (IsASCIIUpper(cc)) {
-        token_->BeginDOCTYPE(ToLowerCase(cc));
-        HTML_ADVANCE_TO(kDOCTYPENameState);
       } else if (cc == '>') {
         ParseError();
         token_->BeginDOCTYPE();
         token_->SetForceQuirks();
         return EmitAndResumeIn(source, HTMLTokenizer::kDataState);
       } else if (cc == kEndOfFileMarker) {
         ParseError();
         token_->BeginDOCTYPE();
         token_->SetForceQuirks();
         return EmitAndReconsumeIn(source, HTMLTokenizer::kDataState);
       } else {
-        token_->BeginDOCTYPE(cc);
+        token_->BeginDOCTYPE(ToLowerCaseIfAlpha(cc));
         HTML_ADVANCE_TO(kDOCTYPENameState);
       }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(kDOCTYPENameState) {
-      if (IsTokenizerWhitespace(cc))
+      if (IsTokenizerWhitespace(cc)) {
         HTML_ADVANCE_TO(kAfterDOCTYPENameState);
-      else if (cc == '>')
+      } else if (cc == '>') {
         return EmitAndResumeIn(source, HTMLTokenizer::kDataState);
-      else if (IsASCIIUpper(cc)) {
-        token_->AppendToName(ToLowerCase(cc));
-        HTML_ADVANCE_TO(kDOCTYPENameState);
       } else if (cc == kEndOfFileMarker) {
         ParseError();
         token_->SetForceQuirks();
         return EmitAndReconsumeIn(source, HTMLTokenizer::kDataState);
       } else {
-        token_->AppendToName(cc);
+        token_->AppendToName(ToLowerCaseIfAlpha(cc));
         HTML_ADVANCE_TO(kDOCTYPENameState);
       }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(kAfterDOCTYPENameState) {
       if (IsTokenizerWhitespace(cc))
         HTML_ADVANCE_TO(kAfterDOCTYPENameState);
       if (cc == '>')
         return EmitAndResumeIn(source, HTMLTokenizer::kDataState);
@@ skipping 366 matching lines @@
   return true;
 }
 
 inline void HTMLTokenizer::ParseError() {
 #if DCHECK_IS_ON()
   DVLOG(1) << "Not implemented.";
 #endif
 }
 
 }  // namespace blink