Rename prelude to range in parsePageSelector

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/CSSCustomPropertyDeclaration.h"
 #include "core/css/CSSKeyframesRule.h"
 #include "core/css/CSSStyleSheet.h"
 #include "core/css/StylePropertySet.h"
@@ skipping 156 matching lines @@
     });
     styleSheet->setHasSyntacticallyValidCSSHeader(firstRuleValid);
     TRACE_EVENT_END0("blink,blink_style", "CSSParserImpl::parseStyleSheet.parse");
 
     TRACE_EVENT_END2(
         "blink,blink_style", "CSSParserImpl::parseStyleSheet",
         "tokenCount", scope.tokenCount(),
         "length", string.length());
 }
 
-CSSSelectorList CSSParserImpl::parsePageSelector(CSSParserTokenRange prelude, StyleSheetContents* styleSheet)
+CSSSelectorList CSSParserImpl::parsePageSelector(CSSParserTokenRange range, StyleSheetContents* styleSheet)
 {
-    prelude.consumeWhitespace();
+    // We only support a small subset of the css-page spec.
+    range.consumeWhitespace();
     AtomicString typeSelector;
-    if (prelude.peek().type() == IdentToken)
-        typeSelector = prelude.consume().value();
+    if (range.peek().type() == IdentToken)
+        typeSelector = range.consume().value();
 
     AtomicString pseudo;
-    if (prelude.peek().type() == ColonToken) {
-        prelude.consume();
-        if (prelude.peek().type() != IdentToken)
+    if (range.peek().type() == ColonToken) {
+        range.consume();
+        if (range.peek().type() != IdentToken)
             return CSSSelectorList();
-        pseudo = prelude.consume().value();
+        pseudo = range.consume().value();
     }
 
-    prelude.consumeWhitespace();
-    if (!prelude.atEnd())
-        return CSSSelectorList(); // Parse error; extra tokens in @page header
+    range.consumeWhitespace();
+    if (!range.atEnd())
+        return CSSSelectorList(); // Parse error; extra tokens in @page selector
 
     OwnPtr<CSSParserSelector> selector;
     if (!typeSelector.isNull() && pseudo.isNull()) {
         selector = CSSParserSelector::create(QualifiedName(nullAtom, typeSelector, styleSheet->defaultNamespace()));
     } else {
         selector = CSSParserSelector::create();
         if (!pseudo.isNull()) {
             selector->setMatch(CSSSelector::PagePseudoClass);
             selector->updatePseudoType(pseudo.lower());
             if (selector->pseudoType() == CSSSelector::PseudoUnknown)
@@ skipping 367 matching lines @@
     consumeRuleList(block, KeyframesRuleList, [keyframeRule](PassRefPtrWillBeRawPtr<StyleRuleBase> keyframe) {
         keyframeRule->parserAppendKeyframe(toStyleRuleKeyframe(keyframe.get()));
     });
     keyframeRule->setName(name);
     keyframeRule->setVendorPrefixed(webkitPrefixed);
     return keyframeRule.release();
 }
 
 PassRefPtrWillBeRawPtr<StyleRulePage> CSSParserImpl::consumePageRule(CSSParserTokenRange prelude, CSSParserTokenRange block)
 {
-    // We only support a small subset of the css-page spec.
     CSSSelectorList selectorList = parsePageSelector(prelude, m_styleSheet);
     if (!selectorList.isValid())
-        return nullptr;
+        return nullptr; // Parse error, invalid @page selector
 
     if (m_observerWrapper) {
         unsigned endOffset = m_observerWrapper->endOffset(prelude);
         m_observerWrapper->observer().startRuleHeader(StyleRule::Page, m_observerWrapper->startOffset(prelude));
         m_observerWrapper->observer().endRuleHeader(endOffset);
     }
 
     consumeDeclarationList(block, StyleRule::Style);
 
     return StyleRulePage::create(std::move(selectorList), createStylePropertySet(m_parsedProperties, m_context.mode()));
@@ skipping 172 matching lines @@
         else
             return nullptr; // Parser error, invalid value in keyframe selector
         if (range.atEnd())
             return result.release();
         if (range.consume().type() != CommaToken)
             return nullptr; // Parser error
     }
 }
 
 } // namespace blink