ABANDONED CL: Changes needed to make things compile after running rewrite_to_chrome_style tool.

third_party/WebKit/Source/core/css/parser/CSSTokenizerTest.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/css/parser/CSSTokenizer.h"
 
 #include "core/css/parser/CSSParserTokenRange.h"
 #include "core/css/parser/MediaQueryBlockWatcher.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/allocator/Partitions.h"
@@ skipping 119 matching lines @@
 // We need to initialize PartitionAlloc before creating CSSParserTokens
 // because CSSParserToken depends on PartitionAlloc. It is safe to call
 // WTF::Partitions::initialize() multiple times.
 #define DEFINE_TOKEN(name, argument)                       \
   static CSSParserToken& name() {                          \
     WTF::Partitions::initialize(nullptr);                  \
     DEFINE_STATIC_LOCAL(CSSParserToken, name, (argument)); \
     return name;                                           \
   }
 
-DEFINE_TOKEN(whitespace, (WhitespaceToken))
-DEFINE_TOKEN(colon, (ColonToken));
-DEFINE_TOKEN(semicolon, (SemicolonToken));
-DEFINE_TOKEN(comma, (CommaToken));
-DEFINE_TOKEN(includeMatch, (IncludeMatchToken));
-DEFINE_TOKEN(dashMatch, (DashMatchToken));
-DEFINE_TOKEN(prefixMatch, (PrefixMatchToken));
-DEFINE_TOKEN(suffixMatch, (SuffixMatchToken));
-DEFINE_TOKEN(substringMatch, (SubstringMatchToken));
-DEFINE_TOKEN(column, (ColumnToken));
-DEFINE_TOKEN(cdo, (CDOToken));
-DEFINE_TOKEN(cdc, (CDCToken));
-DEFINE_TOKEN(leftParenthesis, (LeftParenthesisToken));
-DEFINE_TOKEN(rightParenthesis, (RightParenthesisToken));
-DEFINE_TOKEN(leftBracket, (LeftBracketToken));
-DEFINE_TOKEN(rightBracket, (RightBracketToken));
-DEFINE_TOKEN(leftBrace, (LeftBraceToken));
-DEFINE_TOKEN(rightBrace, (RightBraceToken));
-DEFINE_TOKEN(badString, (BadStringToken));
-DEFINE_TOKEN(badUrl, (BadUrlToken));
+DEFINE_TOKEN(Whitespace, (kWhitespaceToken))
+DEFINE_TOKEN(Colon, (kColonToken));
+DEFINE_TOKEN(Semicolon, (kSemicolonToken));
+DEFINE_TOKEN(Comma, (kCommaToken));
+DEFINE_TOKEN(IncludeMatch, (kIncludeMatchToken));
+DEFINE_TOKEN(DashMatch, (kDashMatchToken));
+DEFINE_TOKEN(PrefixMatch, (kPrefixMatchToken));
+DEFINE_TOKEN(SuffixMatch, (kSuffixMatchToken));
+DEFINE_TOKEN(SubstringMatch, (kSubstringMatchToken));
+DEFINE_TOKEN(Column, (kColumnToken));
+DEFINE_TOKEN(Cdo, (kCDOToken));
+DEFINE_TOKEN(Cdc, (kCDCToken));
+DEFINE_TOKEN(LeftParenthesis, (kLeftParenthesisToken));
+DEFINE_TOKEN(RightParenthesis, (kRightParenthesisToken));
+DEFINE_TOKEN(LeftBracket, (kLeftBracketToken));
+DEFINE_TOKEN(RightBracket, (kRightBracketToken));
+DEFINE_TOKEN(LeftBrace, (kLeftBraceToken));
+DEFINE_TOKEN(RightBrace, (kRightBraceToken));
+DEFINE_TOKEN(BadString, (kBadStringToken));
+DEFINE_TOKEN(BadUrl, (kBadUrlToken));
 
-String fromUChar32(UChar32 c) {
+String FromUChar32(UChar32 c) {
   StringBuilder input;
   input.append(c);
   return input.toString();
 }
 
 TEST(CSSTokenizerTest, SingleCharacterTokens) {
-  TEST_TOKENS("(", leftParenthesis());
-  TEST_TOKENS(")", rightParenthesis());
-  TEST_TOKENS("[", leftBracket());
-  TEST_TOKENS("]", rightBracket());
-  TEST_TOKENS(",", comma());
-  TEST_TOKENS(":", colon());
-  TEST_TOKENS(";", semicolon());
-  TEST_TOKENS(")[", rightParenthesis(), leftBracket());
-  TEST_TOKENS("[)", leftBracket(), rightParenthesis());
-  TEST_TOKENS("{}", leftBrace(), rightBrace());
-  TEST_TOKENS(",,", comma(), comma());
+  TEST_TOKENS("(", LeftParenthesis());
+  TEST_TOKENS(")", RightParenthesis());
+  TEST_TOKENS("[", LeftBracket());
+  TEST_TOKENS("]", RightBracket());
+  TEST_TOKENS(",", Comma());
+  TEST_TOKENS(":", Colon());
+  TEST_TOKENS(";", Semicolon());
+  TEST_TOKENS(")[", RightParenthesis(), LeftBracket());
+  TEST_TOKENS("[)", LeftBracket(), RightParenthesis());
+  TEST_TOKENS("{}", LeftBrace(), RightBrace());
+  TEST_TOKENS(",,", Comma(), Comma());
 }
 
 TEST(CSSTokenizerTest, MultipleCharacterTokens) {
-  TEST_TOKENS("~=", includeMatch());
-  TEST_TOKENS("|=", dashMatch());
-  TEST_TOKENS("^=", prefixMatch());
-  TEST_TOKENS("$=", suffixMatch());
-  TEST_TOKENS("*=", substringMatch());
-  TEST_TOKENS("||", column());
-  TEST_TOKENS("|||", column(), delim('|'));
-  TEST_TOKENS("<!--", cdo());
-  TEST_TOKENS("<!---", cdo(), delim('-'));
-  TEST_TOKENS("-->", cdc());
+  TEST_TOKENS("~=", IncludeMatch());
+  TEST_TOKENS("|=", DashMatch());
+  TEST_TOKENS("^=", PrefixMatch());
+  TEST_TOKENS("$=", SuffixMatch());
+  TEST_TOKENS("*=", SubstringMatch());
+  TEST_TOKENS("||", Column());
+  TEST_TOKENS("|||", Column(), Delim('|'));
+  TEST_TOKENS("<!--", Cdo());
+  TEST_TOKENS("<!---", Cdo(), Delim('-'));
+  TEST_TOKENS("-->", Cdc());
 }
 
 TEST(CSSTokenizerTest, DelimiterToken) {
   TEST_TOKENS("^", delim('^'));
   TEST_TOKENS("*", delim('*'));
   TEST_TOKENS("%", delim('%'));
   TEST_TOKENS("~", delim('~'));
   TEST_TOKENS("&", delim('&'));
   TEST_TOKENS("|", delim('|'));
   TEST_TOKENS("\x7f", delim('\x7f'));
@@ skipping 63 matching lines @@
   TEST_TOKENS(fromUChar32(0xA0),
               ident(fromUChar32(0xA0)));  // non-breaking space
   TEST_TOKENS(fromUChar32(0x1234), ident(fromUChar32(0x1234)));
   TEST_TOKENS(fromUChar32(0x12345), ident(fromUChar32(0x12345)));
   TEST_TOKENS(String("\0", 1), ident(fromUChar32(0xFFFD)));
   TEST_TOKENS(String("ab\0c", 4), ident("ab" + fromUChar32(0xFFFD) + "c"));
   TEST_TOKENS(String("ab\0c", 4), ident("ab" + fromUChar32(0xFFFD) + "c"));
 }
 
 TEST(CSSTokenizerTest, FunctionToken) {
-  TEST_TOKENS("scale(2)", function("scale"),
-              number(IntegerValueType, 2, NoSign), rightParenthesis());
-  TEST_TOKENS("foo-bar\\ baz(", function("foo-bar baz"));
-  TEST_TOKENS("fun\\(ction(", function("fun(ction"));
-  TEST_TOKENS("-foo(", function("-foo"));
-  TEST_TOKENS("url(\"foo.gif\"", function("url"), string("foo.gif"));
-  TEST_TOKENS("foo(  \'bar.gif\'", function("foo"), whitespace(),
-              string("bar.gif"));
+  TEST_TOKENS("scale(2)", Function("scale"),
+              Number(kIntegerValueType, 2, kNoSign), RightParenthesis());
+  TEST_TOKENS("foo-bar\\ baz(", Function("foo-bar baz"));
+  TEST_TOKENS("fun\\(ction(", Function("fun(ction"));
+  TEST_TOKENS("-foo(", Function("-foo"));
+  TEST_TOKENS("url(\"foo.gif\"", Function("url"), GetString("foo.gif"));
+  TEST_TOKENS("foo(  \'bar.gif\'", Function("foo"), Whitespace(),
+              GetString("bar.gif"));
   // To simplify implementation we drop the whitespace in
   // function(url),whitespace,string()
   TEST_TOKENS("url(  \'bar.gif\'", function("url"), string("bar.gif"));
 }
 
 TEST(CSSTokenizerTest, AtKeywordToken) {
   TEST_TOKENS("@at-keyword", atKeyword("at-keyword"));
   TEST_TOKENS("@testing123", atKeyword("testing123"));
   TEST_TOKENS("@hello!", atKeyword("hello"), delim('!'));
   TEST_TOKENS("@-text", atKeyword("-text"));
   TEST_TOKENS("@--abc", atKeyword("--abc"));
   TEST_TOKENS("@--", atKeyword("--"));
   TEST_TOKENS("@--11", atKeyword("--11"));
   TEST_TOKENS("@---", atKeyword("---"));
   TEST_TOKENS("@\\ ", atKeyword(" "));
   TEST_TOKENS("@-\\ ", atKeyword("- "));
   TEST_TOKENS("@@", delim('@'), delim('@'));
   TEST_TOKENS("@2", delim('@'), number(IntegerValueType, 2, NoSign));
   TEST_TOKENS("@-1", delim('@'), number(IntegerValueType, -1, MinusSign));
 }
 
 TEST(CSSTokenizerTest, UrlToken) {
   TEST_TOKENS("url(foo.gif)", url("foo.gif"));
   TEST_TOKENS("urL(https://example.com/cats.png)",
               url("https://example.com/cats.png"));
   TEST_TOKENS("uRl(what-a.crazy^URL~this\\ is!)",
-              url("what-a.crazy^URL~this is!"));
-  TEST_TOKENS("uRL(123#test)", url("123#test"));
-  TEST_TOKENS("Url(escapes\\ \\\"\\'\\)\\()", url("escapes \"')("));
-  TEST_TOKENS("UrL(   whitespace   )", url("whitespace"));
-  TEST_TOKENS("URl( whitespace-eof ", url("whitespace-eof"));
-  TEST_TOKENS("URL(eof", url("eof"));
-  TEST_TOKENS("url(not/*a*/comment)", url("not/*a*/comment"));
-  TEST_TOKENS("urL()", url(""));
-  TEST_TOKENS("uRl(white space),", badUrl(), comma());
-  TEST_TOKENS("Url(b(ad),", badUrl(), comma());
-  TEST_TOKENS("uRl(ba'd):", badUrl(), colon());
-  TEST_TOKENS("urL(b\"ad):", badUrl(), colon());
-  TEST_TOKENS("uRl(b\"ad):", badUrl(), colon());
-  TEST_TOKENS("Url(b\\\rad):", badUrl(), colon());
-  TEST_TOKENS("url(b\\\nad):", badUrl(), colon());
-  TEST_TOKENS("url(/*'bad')*/", badUrl(), delim('*'), delim('/'));
-  TEST_TOKENS("url(ba'd\\\\))", badUrl(), rightParenthesis());
+              Url("what-a.crazy^URL~this is!"));
+  TEST_TOKENS("uRL(123#test)", Url("123#test"));
+  TEST_TOKENS("Url(escapes\\ \\\"\\'\\)\\()", Url("escapes \"')("));
+  TEST_TOKENS("UrL(   whitespace   )", Url("whitespace"));
+  TEST_TOKENS("URl( whitespace-eof ", Url("whitespace-eof"));
+  TEST_TOKENS("URL(eof", Url("eof"));
+  TEST_TOKENS("url(not/*a*/comment)", Url("not/*a*/comment"));
+  TEST_TOKENS("urL()", Url(""));
+  TEST_TOKENS("uRl(white space),", BadUrl(), Comma());
+  TEST_TOKENS("Url(b(ad),", BadUrl(), Comma());
+  TEST_TOKENS("uRl(ba'd):", BadUrl(), Colon());
+  TEST_TOKENS("urL(b\"ad):", BadUrl(), Colon());
+  TEST_TOKENS("uRl(b\"ad):", BadUrl(), Colon());
+  TEST_TOKENS("Url(b\\\rad):", BadUrl(), Colon());
+  TEST_TOKENS("url(b\\\nad):", BadUrl(), Colon());
+  TEST_TOKENS("url(/*'bad')*/", BadUrl(), Delim('*'), Delim('/'));
+  TEST_TOKENS("url(ba'd\\\\))", BadUrl(), RightParenthesis());
 }
 
 TEST(CSSTokenizerTest, StringToken) {
-  TEST_TOKENS("'text'", string("text"));
-  TEST_TOKENS("\"text\"", string("text"));
-  TEST_TOKENS("'testing, 123!'", string("testing, 123!"));
-  TEST_TOKENS("'es\\'ca\\\"pe'", string("es'ca\"pe"));
-  TEST_TOKENS("'\"quotes\"'", string("\"quotes\""));
-  TEST_TOKENS("\"'quotes'\"", string("'quotes'"));
-  TEST_TOKENS("\"mismatch'", string("mismatch'"));
-  TEST_TOKENS("'text\5\t\13'", string("text\5\t\13"));
-  TEST_TOKENS("\"end on eof", string("end on eof"));
-  TEST_TOKENS("'esca\\\nped'", string("escaped"));
-  TEST_TOKENS("\"esc\\\faped\"", string("escaped"));
-  TEST_TOKENS("'new\\\rline'", string("newline"));
-  TEST_TOKENS("\"new\\\r\nline\"", string("newline"));
-  TEST_TOKENS("'bad\nstring", badString(), whitespace(), ident("string"));
-  TEST_TOKENS("'bad\rstring", badString(), whitespace(), ident("string"));
-  TEST_TOKENS("'bad\r\nstring", badString(), whitespace(), ident("string"));
-  TEST_TOKENS("'bad\fstring", badString(), whitespace(), ident("string"));
-  TEST_TOKENS(String("'\0'", 3), string(fromUChar32(0xFFFD)));
+  TEST_TOKENS("'text'", GetString("text"));
+  TEST_TOKENS("\"text\"", GetString("text"));
+  TEST_TOKENS("'testing, 123!'", GetString("testing, 123!"));
+  TEST_TOKENS("'es\\'ca\\\"pe'", GetString("es'ca\"pe"));
+  TEST_TOKENS("'\"quotes\"'", GetString("\"quotes\""));
+  TEST_TOKENS("\"'quotes'\"", GetString("'quotes'"));
+  TEST_TOKENS("\"mismatch'", GetString("mismatch'"));
+  TEST_TOKENS("'text\5\t\13'", GetString("text\5\t\13"));
+  TEST_TOKENS("\"end on eof", GetString("end on eof"));
+  TEST_TOKENS("'esca\\\nped'", GetString("escaped"));
+  TEST_TOKENS("\"esc\\\faped\"", GetString("escaped"));
+  TEST_TOKENS("'new\\\rline'", GetString("newline"));
+  TEST_TOKENS("\"new\\\r\nline\"", GetString("newline"));
+  TEST_TOKENS("'bad\nstring", BadString(), Whitespace(), Ident("string"));
+  TEST_TOKENS("'bad\rstring", BadString(), Whitespace(), Ident("string"));
+  TEST_TOKENS("'bad\r\nstring", BadString(), Whitespace(), Ident("string"));
+  TEST_TOKENS("'bad\fstring", BadString(), Whitespace(), Ident("string"));
+  TEST_TOKENS(String("'\0'", 3), GetString(FromUChar32(0xFFFD)));
   TEST_TOKENS(String("'hel\0lo'", 8),
               string("hel" + fromUChar32(0xFFFD) + "lo"));
   TEST_TOKENS(String("'h\\65l\0lo'", 10),
               string("hel" + fromUChar32(0xFFFD) + "lo"));
 }
 
 TEST(CSSTokenizerTest, HashToken) {
   TEST_TOKENS("#id-selector", hash("id-selector", HashTokenId));
   TEST_TOKENS("#FF7700", hash("FF7700", HashTokenId));
   TEST_TOKENS("#3377FF", hash("3377FF", HashTokenUnrestricted));
@@ skipping 85 matching lines @@
               number(IntegerValueType, -123, MinusSign));
   TEST_TOKENS("u+1??4", unicodeRange(0x100, 0x1ff),
               number(IntegerValueType, 4, NoSign));
   TEST_TOKENS("u+z", ident("u"), delim('+'), ident("z"));
   TEST_TOKENS("u+", ident("u"), delim('+'));
   TEST_TOKENS("u+-543", ident("u"), delim('+'),
               number(IntegerValueType, -543, MinusSign));
 }
 
 TEST(CSSTokenizerTest, CommentToken) {
-  TEST_TOKENS("/*comment*/a", ident("a"));
-  TEST_TOKENS("/**\\2f**//", delim('/'));
-  TEST_TOKENS("/**y*a*y**/ ", whitespace());
-  TEST_TOKENS(",/* \n :) \n */)", comma(), rightParenthesis());
-  TEST_TOKENS(":/*/*/", colon());
-  TEST_TOKENS("/**/*", delim('*'));
-  TEST_TOKENS(";/******", semicolon());
+  TEST_TOKENS("/*comment*/a", Ident("a"));
+  TEST_TOKENS("/**\\2f**//", Delim('/'));
+  TEST_TOKENS("/**y*a*y**/ ", Whitespace());
+  TEST_TOKENS(",/* \n :) \n */)", Comma(), RightParenthesis());
+  TEST_TOKENS(":/*/*/", Colon());
+  TEST_TOKENS("/**/*", Delim('*'));
+  TEST_TOKENS(";/******", Semicolon());
 }
 
 typedef struct {
   const char* input;
   const unsigned maxLevel;
   const unsigned finalLevel;
 } BlockTestCase;
 
 TEST(CSSTokenizerBlockTest, Basic) {
   BlockTestCase testCases[] = {
@@ skipping 36 matching lines @@
       blockWatcher.handleToken(range.consume());
       level = blockWatcher.blockLevel();
       maxLevel = std::max(level, maxLevel);
     }
     ASSERT_EQ(testCases[i].maxLevel, maxLevel);
     ASSERT_EQ(testCases[i].finalLevel, level);
   }
 }
 
 }  // namespace blink