Replace CSSParserString with StringView.

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 11 matching lines @@
 {
     ASSERT_EQ(expected.type(), actual.type());
     switch (expected.type()) {
     case DelimiterToken:
         ASSERT_EQ(expected.delimiter(), actual.delimiter());
         break;
     case IdentToken:
     case FunctionToken:
     case StringToken:
     case UrlToken:
-        ASSERT_EQ(String(expected.value()), String(actual.value()));
+        ASSERT_EQ(expected.value(), actual.value());
         break;
     case DimensionToken:
-        ASSERT_EQ(String(expected.value()), String(actual.value()));
+        ASSERT_EQ(expected.value(), actual.value());
         ASSERT_EQ(expected.numericValueType(), actual.numericValueType());
         ASSERT_DOUBLE_EQ(expected.numericValue(), actual.numericValue());
         break;
     case NumberToken:
         ASSERT_EQ(expected.numericSign(), actual.numericSign());
         // fallthrough
     case PercentageToken:
         ASSERT_EQ(expected.numericValueType(), actual.numericValueType());
         ASSERT_DOUBLE_EQ(expected.numericValue(), actual.numericValue());
         break;
     case UnicodeRangeToken:
         ASSERT_EQ(expected.unicodeRangeStart(), actual.unicodeRangeStart());
         ASSERT_EQ(expected.unicodeRangeEnd(), actual.unicodeRangeEnd());
         break;
     case HashToken:
-        ASSERT_EQ(String(expected.value()), String(actual.value()));
+        ASSERT_EQ(expected.value(), actual.value());
         ASSERT_EQ(expected.getHashTokenType(), actual.getHashTokenType());
         break;
     default:
         break;
     }
 }
 
 void testTokens(const String& string, const CSSParserToken& token1, const CSSParserToken& token2 = CSSParserToken(EOFToken), const CSSParserToken& token3 = CSSParserToken(EOFToken))
 {
     Vector<CSSParserToken> expectedTokens;
     expectedTokens.append(token1);
     if (token2.type() != EOFToken) {
         expectedTokens.append(token2);
         if (token3.type() != EOFToken)
             expectedTokens.append(token3);
     }
 
     CSSParserTokenRange expected(expectedTokens);
 
     CSSTokenizer::Scope actualScope(string);
     CSSParserTokenRange actual = actualScope.tokenRange();
 
     // Just check that serialization doesn't hit any asserts
     actual.serialize();
 
     while (!expected.atEnd() || !actual.atEnd())
         compareTokens(expected.consume(), actual.consume());
 }
 
-static CSSParserString toParserString(const String& string)
-{
-    CSSParserString result;
-    result.init(string);
-    return result;
-}
-
-static CSSParserToken ident(const String& string) { return CSSParserToken(IdentToken, toParserString(string)); }
-static CSSParserToken atKeyword(const String& string) { return CSSParserToken(AtKeywordToken, toParserString(string)); }
-static CSSParserToken string(const String& string) { return CSSParserToken(StringToken, toParserString(string)); }
-static CSSParserToken function(const String& string) { return CSSParserToken(FunctionToken, toParserString(string)); }
-static CSSParserToken url(const String& string) { return CSSParserToken(UrlToken, toParserString(string)); }
-static CSSParserToken hash(const String& string, HashTokenType type) { return CSSParserToken(type, toParserString(string)); }
+static CSSParserToken ident(const String& string) { return CSSParserToken(IdentToken, string); }
+static CSSParserToken atKeyword(const String& string) { return CSSParserToken(AtKeywordToken, string); }
+static CSSParserToken string(const String& string) { return CSSParserToken(StringToken, string); }
+static CSSParserToken function(const String& string) { return CSSParserToken(FunctionToken, string); }
+static CSSParserToken url(const String& string) { return CSSParserToken(UrlToken, string); }
+static CSSParserToken hash(const String& string, HashTokenType type) { return CSSParserToken(type, string); }
 static CSSParserToken delim(char c) { return CSSParserToken(DelimiterToken, c); }
 
 static CSSParserToken unicodeRange(UChar32 start, UChar32 end)
 {
     return CSSParserToken(UnicodeRangeToken, start, end);
 }
 
 static CSSParserToken number(NumericValueType type, double value, NumericSign sign)
 {
     return CSSParserToken(NumberToken, value, type, sign);
 }
 
 static CSSParserToken dimension(NumericValueType type, double value, const String& string)
 {
     CSSParserToken token = number(type, value, NoSign); // sign ignored
-    token.convertToDimensionWithUnit(toParserString(string));
+    token.convertToDimensionWithUnit(string);
     return token;
 }
 
 static CSSParserToken percentage(NumericValueType type, double value)
 {
     CSSParserToken token = number(type, value, NoSign); // sign ignored
     token.convertToPercentage();
     return token;
 }
 
@@ skipping 373 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