Consolidate consumeWhitespace calls to one line

third_party/WebKit/Source/core/css/parser/CSSParserImpl.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/CSSParserImpl.h"
 
 #include "core/css/CSSCustomIdentValue.h"
 #include "core/css/CSSCustomPropertyDeclaration.h"
 #include "core/css/CSSKeyframesRule.h"
 #include "core/css/CSSStyleSheet.h"
@@ skipping 340 matching lines @@
             callback(rule);
         }
     }
 
     return firstRuleValid;
 }
 
 StyleRuleBase* CSSParserImpl::consumeAtRule(CSSParserTokenRange& range, AllowedRulesType allowedRules)
 {
     ASSERT(range.peek().type() == AtKeywordToken);
-    const StringView name = range.consume().value();
+    const StringView name = range.consumeIncludingWhitespace().value();
     const CSSParserToken* preludeStart = &range.peek();
     while (!range.atEnd() && range.peek().type() != LeftBraceToken && range.peek().type() != SemicolonToken)
         range.consumeComponentValue();
 
     CSSParserTokenRange prelude = range.makeSubRange(preludeStart, &range.peek());
     CSSAtRuleID id = cssAtRuleID(name);
     if (id != CSSAtRuleInvalid && m_context.useCounter())
         countAtRule(m_context.useCounter(), id);
 
     if (range.atEnd() || range.peek().type() == SemicolonToken) {
@@ skipping 74 matching lines @@
     CSSParserTokenRange contents = range.consumeBlock();
     const CSSParserToken& uri = contents.consumeIncludingWhitespace();
     if (uri.type() == BadStringToken || !contents.atEnd())
         return AtomicString();
     DCHECK_EQ(uri.type(), StringToken);
     return uri.value().toAtomicString();
 }
 
 StyleRuleCharset* CSSParserImpl::consumeCharsetRule(CSSParserTokenRange prelude)
 {
-    prelude.consumeWhitespace();
     const CSSParserToken& string = prelude.consumeIncludingWhitespace();
     if (string.type() != StringToken || !prelude.atEnd())
         return nullptr; // Parse error, expected a single string
     return StyleRuleCharset::create();
 }
 
 StyleRuleImport* CSSParserImpl::consumeImportRule(CSSParserTokenRange prelude)
 {
-    prelude.consumeWhitespace();
     AtomicString uri(consumeStringOrURI(prelude));
     if (uri.isNull())
         return nullptr; // Parse error, expected string or URI
 
     if (m_observerWrapper) {
         unsigned endOffset = m_observerWrapper->endOffset(prelude);
         m_observerWrapper->observer().startRuleHeader(StyleRule::Import, m_observerWrapper->startOffset(prelude));
         m_observerWrapper->observer().endRuleHeader(endOffset);
         m_observerWrapper->observer().startRuleBody(endOffset);
         m_observerWrapper->observer().endRuleBody(endOffset);
     }
 
     return StyleRuleImport::create(uri, MediaQueryParser::parseMediaQuerySet(prelude));
 }
 
 StyleRuleNamespace* CSSParserImpl::consumeNamespaceRule(CSSParserTokenRange prelude)
 {
-    prelude.consumeWhitespace();
     AtomicString namespacePrefix;
     if (prelude.peek().type() == IdentToken)
         namespacePrefix = prelude.consumeIncludingWhitespace().value().toAtomicString();
 
     AtomicString uri(consumeStringOrURI(prelude));
-    prelude.consumeWhitespace();
     if (uri.isNull() || !prelude.atEnd())
         return nullptr; // Parse error, expected string or URI
 
     return StyleRuleNamespace::create(namespacePrefix, uri);
 }
 
 StyleRuleMedia* CSSParserImpl::consumeMediaRule(CSSParserTokenRange prelude, CSSParserTokenRange block)
 {
     HeapVector<Member<StyleRuleBase>> rules;
 
     if (m_observerWrapper) {
-        CSSParserTokenRange preludeWithoutWhitespace = prelude;
-        preludeWithoutWhitespace.consumeWhitespace();
-        m_observerWrapper->observer().startRuleHeader(StyleRule::Media, m_observerWrapper->startOffset(preludeWithoutWhitespace));
-        m_observerWrapper->observer().endRuleHeader(m_observerWrapper->endOffset(preludeWithoutWhitespace));
+        m_observerWrapper->observer().startRuleHeader(StyleRule::Media, m_observerWrapper->startOffset(prelude));
+        m_observerWrapper->observer().endRuleHeader(m_observerWrapper->endOffset(prelude));
         m_observerWrapper->observer().startRuleBody(m_observerWrapper->previousTokenStartOffset(block));
     }
 
     if (m_styleSheet)
         m_styleSheet->setHasMediaQueries();
 
     consumeRuleList(block, RegularRuleList, [&rules](StyleRuleBase* rule) {
         rules.append(rule);
     });
 
@@ skipping 25 matching lines @@
 
     return StyleRuleSupports::create(prelude.serialize().stripWhiteSpace(), supported, rules);
 }
 
 StyleRuleViewport* CSSParserImpl::consumeViewportRule(CSSParserTokenRange prelude, CSSParserTokenRange block)
 {
     // Allow @viewport rules from UA stylesheets even if the feature is disabled.
     if (!RuntimeEnabledFeatures::cssViewportEnabled() && !isUASheetBehavior(m_context.mode()))
         return nullptr;
 
-    prelude.consumeWhitespace();
     if (!prelude.atEnd())
         return nullptr; // Parser error; @viewport prelude should be empty
 
     if (m_observerWrapper) {
         unsigned endOffset = m_observerWrapper->endOffset(prelude);
         m_observerWrapper->observer().startRuleHeader(StyleRule::Viewport, m_observerWrapper->startOffset(prelude));
         m_observerWrapper->observer().endRuleHeader(endOffset);
         m_observerWrapper->observer().startRuleBody(endOffset);
         m_observerWrapper->observer().endRuleBody(endOffset);
     }
 
     consumeDeclarationList(block, StyleRule::Viewport);
     return StyleRuleViewport::create(createStylePropertySet(m_parsedProperties, CSSViewportRuleMode));
 }
 
 StyleRuleFontFace* CSSParserImpl::consumeFontFaceRule(CSSParserTokenRange prelude, CSSParserTokenRange block)
 {
-    prelude.consumeWhitespace();
     if (!prelude.atEnd())
         return nullptr; // Parse error; @font-face prelude should be empty
 
     if (m_observerWrapper) {
         unsigned endOffset = m_observerWrapper->endOffset(prelude);
         m_observerWrapper->observer().startRuleHeader(StyleRule::FontFace, m_observerWrapper->startOffset(prelude));
         m_observerWrapper->observer().endRuleHeader(endOffset);
         m_observerWrapper->observer().startRuleBody(endOffset);
         m_observerWrapper->observer().endRuleBody(endOffset);
     }
 
     if (m_styleSheet)
         m_styleSheet->setHasFontFaceRule();
 
     consumeDeclarationList(block, StyleRule::FontFace);
     return StyleRuleFontFace::create(createStylePropertySet(m_parsedProperties, m_context.mode()));
 }
 
 StyleRuleKeyframes* CSSParserImpl::consumeKeyframesRule(bool webkitPrefixed, CSSParserTokenRange prelude, CSSParserTokenRange block)
 {
-    prelude.consumeWhitespace();
     CSSParserTokenRange rangeCopy = prelude; // For inspector callbacks
     const CSSParserToken& nameToken = prelude.consumeIncludingWhitespace();
     if (!prelude.atEnd())
         return nullptr; // Parse error; expected single non-whitespace token in @keyframes header
 
     String name;
     if (nameToken.type() == IdentToken) {
         name = nameToken.value().toString();
     } else if (nameToken.type() == StringToken && webkitPrefixed) {
         if (m_context.useCounter())
@@ skipping 33 matching lines @@
 
     consumeDeclarationList(block, StyleRule::Style);
 
     return StyleRulePage::create(std::move(selectorList), createStylePropertySet(m_parsedProperties, m_context.mode()));
 }
 
 void CSSParserImpl::consumeApplyRule(CSSParserTokenRange prelude)
 {
     ASSERT(RuntimeEnabledFeatures::cssApplyAtRulesEnabled());
 
-    prelude.consumeWhitespace();
     const CSSParserToken& ident = prelude.consumeIncludingWhitespace();
     if (!prelude.atEnd() || !CSSVariableParser::isValidVariableName(ident))
         return; // Parse error, expected a single custom property name
     m_parsedProperties.append(CSSProperty(
         CSSPropertyApplyAtRule,
         *CSSCustomIdentValue::create(ident.value().toString())));
 }
 
 StyleRuleKeyframe* CSSParserImpl::consumeKeyframeStyleRule(CSSParserTokenRange prelude, CSSParserTokenRange block)
 {
@@ skipping 169 matching lines @@
         else
             return nullptr; // Parser error, invalid value in keyframe selector
         if (range.atEnd())
             return result;
         if (range.consume().type() != CommaToken)
             return nullptr; // Parser error
     }
 }
 
 } // namespace blink