Reporing invalid CSS selectors.

Source/core/css/CSSParser.cpp

 /*
  * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved.
  * Copyright (C) 2012 Intel Corporation. All rights reserved.
  *
@@ skipping 235 matching lines @@
     , m_styleSheet(0)
     , m_supportsCondition(false)
     , m_selectorListForParseSelector(0)
     , m_numParsedPropertiesBeforeMarginBox(INVALID_NUM_PARSED_PROPERTIES)
     , m_inParseShorthand(0)
     , m_currentShorthand(CSSPropertyInvalid)
     , m_implicitShorthand(false)
     , m_hasFontFaceOnlyValues(false)
     , m_hadSyntacticallyValidCSSRule(false)
     , m_logErrors(false)
-    , m_ignoreErrorsInDeclaration(false)
+    , m_ignoreErrors(false)
     , m_inFilterRule(false)
     , m_defaultNamespace(starAtom)
     , m_parsedTextPrefixLength(0)
     , m_parsedTextSuffixLength(0)
     , m_sourceDataHandler(0)
     , m_parsingMode(NormalMode)
     , m_is8BitSource(false)
     , m_currentCharacter8(0)
     , m_currentCharacter16(0)
     , m_source(0)
     , m_length(0)
     , m_token(0)
     , m_lineNumber(0)
     , m_tokenStartLineNumber(0)
     , m_lastSelectorLineNumber(0)
+    , m_ruleHeaderType(CSSRuleSourceData::UNKNOWN_RULE)
     , m_allowImportRules(true)
     , m_allowNamespaceDeclarations(true)
 #if ENABLE(CSS_DEVICE_ADAPTATION)
     , m_inViewport(false)
 #endif
     , m_useCounter(counter)
 {
 #if YYDEBUG > 0
     cssyydebug = 1;
 #endif
@@ skipping 13 matching lines @@
 
 AtomicString CSSParserString::atomicSubstring(unsigned position, unsigned length) const
 {
     ASSERT(m_length >= position + length);
 
     if (is8Bit())
         return AtomicString(characters8() + position, length);
     return AtomicString(characters16() + position, length);
 }
 
+void CSSParserString::trimTrailingWhitespace()
+{
+    if (is8Bit()) {
+        while (m_length > 0 && isHTMLSpace(m_data.characters8[m_length - 1]))
+            --m_length;
+    } else {
+        while (m_length > 0 && isHTMLSpace(m_data.characters16[m_length - 1]))
+            --m_length;
+    }
+}
+
 void CSSParser::setupParser(const char* prefix, unsigned prefixLength, const String& string, const char* suffix, unsigned suffixLength)
 {
     m_parsedTextPrefixLength = prefixLength;
     m_parsedTextSuffixLength = suffixLength;
     unsigned stringLength = string.length();
     unsigned length = stringLength + m_parsedTextPrefixLength + m_parsedTextSuffixLength + 1;
     m_length = length;
 
     if (!stringLength || string.is8Bit()) {
         m_dataStart8 = adoptArrayPtr(new LChar[length]);
@@ skipping 37 matching lines @@
     setTokenStart<UChar>(m_currentCharacter16);
     m_lexFunc = &CSSParser::realLex<UChar>;
 }
 
 void CSSParser::parseSheet(StyleSheetContents* sheet, const String& string, int startLineNumber, SourceDataHandler* sourceDataHandler, bool logErrors)
 {
     setStyleSheet(sheet);
     m_defaultNamespace = starAtom; // Reset the default namespace.
     m_sourceDataHandler = sourceDataHandler;
     m_logErrors = logErrors && sheet->singleOwnerDocument() && !sheet->baseURL().isEmpty() && sheet->singleOwnerDocument()->page();
-    m_ignoreErrorsInDeclaration = false;
+    m_ignoreErrors = false;
     m_lineNumber = startLineNumber;
     m_source = &string;
     setupParser("", string, "");
     cssyyparse(this);
     sheet->shrinkToFit();
     m_source = 0;
     m_sourceDataHandler = 0;
     m_rule = 0;
-    m_ignoreErrorsInDeclaration = false;
+    m_ignoreErrors = false;
     m_logErrors = false;
 }
 
 PassRefPtr<StyleRuleBase> CSSParser::parseRule(StyleSheetContents* sheet, const String& string)
 {
     setStyleSheet(sheet);
     m_allowNamespaceDeclarations = false;
     setupParser("@-internal-rule{", string, "} ");
     cssyyparse(this);
     return m_rule.release();
@@ skipping 9014 matching lines @@
 inline UChar* CSSParser::tokenStart<UChar>()
 {
     return m_tokenStart.ptr16;
 }
 
 CSSParserLocation CSSParser::currentLocation()
 {
     CSSParserLocation location;
     location.lineNumber = m_tokenStartLineNumber;
     if (is8BitSource())
-        location.content.init(tokenStart<LChar>(), currentCharacter<LChar>() - tokenStart<LChar>());
+        location.token.init(tokenStart<LChar>(), currentCharacter<LChar>() - tokenStart<LChar>());
     else
-        location.content.init(tokenStart<UChar>(), currentCharacter<UChar>() - tokenStart<UChar>());
+        location.token.init(tokenStart<UChar>(), currentCharacter<UChar>() - tokenStart<UChar>());
     return location;
 }
 
-CSSParserLocation CSSParser::getSource(const CSSParserLocation& begin, const CSSParserLocation& end) const
-{
-    if (!m_source)
-        return begin;
-
-    CSSParserLocation location;
-    location.lineNumber = begin.lineNumber;
-    if (is8BitSource())
-        location.content.init(*m_source, begin.content.characters8() - m_dataStart8.get(), end.content.characters8() - begin.content.characters8());
-    else
-        location.content.init(*m_source, begin.content.characters16() - m_dataStart16.get(), end.content.characters16() - begin.content.characters16());
-    return location;
-}
-
 template <typename CharacterType>
 inline bool CSSParser::isIdentifierStart()
 {
     // Check whether an identifier is started.
     return isIdentifierStartAfterDash((*currentCharacter<CharacterType>() != '-') ? currentCharacter<CharacterType>() : currentCharacter<CharacterType>() + 1);
 }
 
 template <typename CharacterType>
 static inline CharacterType* checkAndSkipString(CharacterType* currentCharacter, int quote)
 {
@@ skipping 1492 matching lines @@
     size_t length = token.length();
     if (is8BitSource()) {
         size_t offset = token.characters8() - m_dataStart8.get();
         makeLower(token.characters8(), m_dataStart8.get() + offset, length);
     } else {
         size_t offset = token.characters16() - m_dataStart16.get();
         makeLower(token.characters16(), m_dataStart16.get() + offset, length);
     }
 }
 
+void CSSParser::endInvalidRuleHeader()
+{
+    if (m_ruleHeaderType == CSSRuleSourceData::UNKNOWN_RULE)
+        return;
+
+    CSSParserLocation location;
+    location.lineNumber = m_ruleHeaderStartLineNumber;
+    if (is8BitSource())
+        location.token.init(m_dataStart8.get() + m_ruleHeaderStartOffset, 0);
+    else
+        location.token.init(m_dataStart16.get() + m_ruleHeaderStartOffset, 0);
+
+    reportError(location, m_ruleHeaderType == CSSRuleSourceData::STYLE_RULE ? InvalidSelectorError : InvalidRuleError);
+
+    endRuleHeader();
+}
+
 void CSSParser::reportError(const CSSParserLocation& location, ErrorType error)
 {
     if (!isLoggingErrors())
         return;
 
-    m_ignoreErrorsInDeclaration = true;
-    if (!InspectorInstrumentation::cssErrorFilter(location, m_id, error))
+    m_ignoreErrors = true;
+    CSSParserString content = location.token;
+    if (error == InvalidPropertyValueError || error == InvalidSelectorError) {
+        if (m_source) {
+            if (is8BitSource())
+                content.init(*m_source, location.token.characters8() - m_dataStart8.get(), tokenStart<LChar>() - location.token.characters8());
+            else
+                content.init(*m_source, location.token.characters16() - m_dataStart16.get(), tokenStart<UChar>() - location.token.characters16());
+            content.trimTrailingWhitespace();
+        }
+    }
+
+    if (!InspectorInstrumentation::cssErrorFilter(content, m_id, error))
         return;
 
     StringBuilder builder;
     switch (error) {
     case PropertyDeclarationError:
         builder.appendLiteral("Invalid CSS property declaration at: ");
         break;
 
     case InvalidPropertyValueError:
         builder.appendLiteral("Invalid CSS property value: ");
         break;
 
     case InvalidPropertyError:
         builder.appendLiteral("Invalid CSS property name: ");
         break;
 
+    case InvalidSelectorError:
+        builder.appendLiteral("Invalid CSS selector: ");
+        break;
+
+    case InvalidRuleError:
+        builder.appendLiteral("Invalid CSS rule: ");
+        break;
+
     default:
         builder.appendLiteral("Unexpected CSS token: ");
     }
 
-    if (location.content.is8Bit())
-        builder.append(location.content.characters8(), location.content.length());
+    if (content.is8Bit())
+        builder.append(content.characters8(), content.length());
     else
-        builder.append(location.content.characters16(), location.content.length());
+        builder.append(content.characters16(), content.length());
 
     logError(builder.toString(), location.lineNumber);
 }
 
 bool CSSParser::isLoggingErrors()
 {
-    return m_logErrors && !m_ignoreErrorsInDeclaration;
+    return m_logErrors && !m_ignoreErrors;
 }
 
 void CSSParser::logError(const String& message, int lineNumber)
 {
     PageConsole* console = m_styleSheet->singleOwnerDocument()->page()->console();
     console->addMessage(CSSMessageSource, WarningMessageLevel, message, m_styleSheet->baseURL().string(), lineNumber + 1);
 }
 
 StyleRuleKeyframes* CSSParser::createKeyframesRule(const String& name, PassOwnPtr<Vector<RefPtr<StyleKeyframe> > > popKeyframes)
 {
@@ skipping 303 matching lines @@
     m_lastSelectorLineNumber = m_lineNumber;
 }
 
 void CSSParser::updateLastMediaLine(MediaQuerySet* media)
 {
     media->setLastLine(m_lineNumber);
 }
 
 void CSSParser::startRuleHeader(CSSRuleSourceData::Type ruleType)
 {
+    m_ruleHeaderType = ruleType;
+    m_ruleHeaderStartOffset = safeUserStringTokenOffset();
+    m_ruleHeaderStartLineNumber = m_tokenStartLineNumber;
     if (m_sourceDataHandler)
-        m_sourceDataHandler->startRuleHeader(ruleType, safeUserStringTokenOffset());
+        m_sourceDataHandler->startRuleHeader(ruleType, m_ruleHeaderStartOffset);
 }
 
 void CSSParser::endRuleHeader()
 {
+    m_ruleHeaderType = CSSRuleSourceData::UNKNOWN_RULE;
     if (m_sourceDataHandler)
         m_sourceDataHandler->endRuleHeader(safeUserStringTokenOffset());
 }
 
 void CSSParser::startSelector()
 {
     if (m_sourceDataHandler)
         m_sourceDataHandler->startSelector(safeUserStringTokenOffset());
 }
 
@@ skipping 10 matching lines @@
 }
 
 void CSSParser::endRuleBody(bool discard)
 {
     if (m_sourceDataHandler)
         m_sourceDataHandler->endRuleBody(safeUserStringTokenOffset(), discard);
 }
 
 void CSSParser::startProperty()
 {
-    m_ignoreErrorsInDeclaration = false;
+    resumeErrorLogging();
     if (m_sourceDataHandler)
         m_sourceDataHandler->startProperty(safeUserStringTokenOffset());
 }
 
 void CSSParser::endProperty(bool isImportantFound, bool isPropertyParsed, ErrorType errorType)
 {
     m_id = CSSPropertyInvalid;
     if (m_sourceDataHandler)
         m_sourceDataHandler->endProperty(isImportantFound, isPropertyParsed, safeUserStringTokenOffset(), errorType);
 }
@@ skipping 352 matching lines @@
 bool isValidNthToken(const CSSParserString& token)
 {
     // The tokenizer checks for the construct of an+b.
     // However, since the {ident} rule precedes the {nth} rule, some of those
     // tokens are identified as string literal. Furthermore we need to accept
     // "odd" and "even" which does not match to an+b.
     return equalIgnoringCase(token, "odd") || equalIgnoringCase(token, "even")
         || equalIgnoringCase(token, "n") || equalIgnoringCase(token, "-n");
 }
 
-CSSParserLocation CSSParserLocation::trimTrailingWhitespace() const
-{
-    CSSParserLocation result;
-    result.lineNumber = lineNumber;
-    result.content = content;
-    size_t newLength = content.length();
-    while (newLength > 0 && isHTMLSpace(result.content[newLength - 1]))
-        --newLength;
-    result.content.setLength(newLength);
-    return result;
 }
-
-}