<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[167571] trunk/Source/WebCore</title>
</head>
<body>
<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/167571">167571</a></dd>
<dt>Author</dt> <dd>benjamin@webkit.org</dd>
<dt>Date</dt> <dd>2014-04-20 13:43:35 -0700 (Sun, 20 Apr 2014)</dd>
</dl>
<h3>Log Message</h3>
<pre>Rename the CSSSelector PseudoType to PseudoClassType
https://bugs.webkit.org/show_bug.cgi?id=131907
Reviewed by Andreas Kling.
Pseudo Elements and Page Pseudo Classes have been moved out of PseudoType in previous patches.
The remaining values in the PseudoType enumeration are the pseudo classes.
This patch is the final clean up, PseudoType is renamed to PseudoClassType.
* css/CSSGrammar.y.in:
* css/CSSParserValues.cpp:
(WebCore::CSSParserSelector::parsePseudoClassAndCompatibilityElementSelector):
* css/CSSParserValues.h:
(WebCore::CSSParserSelector::pseudoClassType):
(WebCore::CSSParserSelector::pseudoType): Deleted.
* css/CSSSelector.cpp:
(WebCore::CSSSelector::specificityForOneSelector):
(WebCore::appendPseudoClassFunctionTail):
(WebCore::CSSSelector::selectorText):
* css/CSSSelector.h:
(WebCore::CSSSelector::pseudoClassType):
(WebCore::CSSSelector::pseudoElementType):
(WebCore::CSSSelector::pagePseudoClassType):
(WebCore::pseudoClassIsRelativeToSiblings):
(WebCore::CSSSelector::isSiblingSelector):
(WebCore::CSSSelector::CSSSelector):
(WebCore::CSSSelector::pseudoType): Deleted.
* css/RuleSet.cpp:
(WebCore::RuleSet::findBestRuleSetAndAdd):
* css/SelectorChecker.cpp:
(WebCore::SelectorChecker::checkOne):
(WebCore::SelectorChecker::checkScrollbarPseudoClass):
(WebCore::SelectorChecker::determineLinkMatchType):
(WebCore::SelectorChecker::matchesFocusPseudoClass):
* css/SelectorChecker.h:
(WebCore::SelectorChecker::isCommonPseudoClassSelector):
* css/SelectorCheckerFastPath.cpp:
(WebCore::SelectorCheckerFastPath::commonPseudoClassSelectorMatches):
* css/SelectorPseudoClassAndCompatibilityElementMap.in:
* css/SelectorPseudoTypeMap.h:
* css/StyleResolver.cpp:
(WebCore::StyleResolver::styleForElement):
* css/makeSelectorPseudoClassAndCompatibilityElementMap.py:
(enumerablePseudoType):
* cssjit/SelectorCompiler.cpp:
(WebCore::SelectorCompiler::addPseudoClassType):
(WebCore::SelectorCompiler::SelectorCodeGenerator::SelectorCodeGenerator):
(WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementMatching):
(WebCore::SelectorCompiler::addPseudoType): Deleted.
* inspector/InspectorCSSAgent.cpp:
(WebCore::computePseudoClassMask):
(WebCore::InspectorCSSAgent::forcePseudoState):
* inspector/InspectorCSSAgent.h:
* inspector/InspectorInstrumentation.cpp:
(WebCore::InspectorInstrumentation::forcePseudoStateImpl):
* inspector/InspectorInstrumentation.h:
(WebCore::InspectorInstrumentation::forcePseudoState):</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceWebCoreChangeLog">trunk/Source/WebCore/ChangeLog</a></li>
<li><a href="#trunkSourceWebCorecssCSSGrammaryin">trunk/Source/WebCore/css/CSSGrammar.y.in</a></li>
<li><a href="#trunkSourceWebCorecssCSSParserValuescpp">trunk/Source/WebCore/css/CSSParserValues.cpp</a></li>
<li><a href="#trunkSourceWebCorecssCSSParserValuesh">trunk/Source/WebCore/css/CSSParserValues.h</a></li>
<li><a href="#trunkSourceWebCorecssCSSSelectorcpp">trunk/Source/WebCore/css/CSSSelector.cpp</a></li>
<li><a href="#trunkSourceWebCorecssCSSSelectorh">trunk/Source/WebCore/css/CSSSelector.h</a></li>
<li><a href="#trunkSourceWebCorecssRuleSetcpp">trunk/Source/WebCore/css/RuleSet.cpp</a></li>
<li><a href="#trunkSourceWebCorecssSelectorCheckercpp">trunk/Source/WebCore/css/SelectorChecker.cpp</a></li>
<li><a href="#trunkSourceWebCorecssSelectorCheckerh">trunk/Source/WebCore/css/SelectorChecker.h</a></li>
<li><a href="#trunkSourceWebCorecssSelectorCheckerFastPathcpp">trunk/Source/WebCore/css/SelectorCheckerFastPath.cpp</a></li>
<li><a href="#trunkSourceWebCorecssSelectorPseudoClassAndCompatibilityElementMapin">trunk/Source/WebCore/css/SelectorPseudoClassAndCompatibilityElementMap.in</a></li>
<li><a href="#trunkSourceWebCorecssSelectorPseudoTypeMaph">trunk/Source/WebCore/css/SelectorPseudoTypeMap.h</a></li>
<li><a href="#trunkSourceWebCorecssStyleResolvercpp">trunk/Source/WebCore/css/StyleResolver.cpp</a></li>
<li><a href="#trunkSourceWebCorecssmakeSelectorPseudoClassAndCompatibilityElementMappy">trunk/Source/WebCore/css/makeSelectorPseudoClassAndCompatibilityElementMap.py</a></li>
<li><a href="#trunkSourceWebCorecssjitSelectorCompilercpp">trunk/Source/WebCore/cssjit/SelectorCompiler.cpp</a></li>
<li><a href="#trunkSourceWebCoreinspectorInspectorCSSAgentcpp">trunk/Source/WebCore/inspector/InspectorCSSAgent.cpp</a></li>
<li><a href="#trunkSourceWebCoreinspectorInspectorCSSAgenth">trunk/Source/WebCore/inspector/InspectorCSSAgent.h</a></li>
<li><a href="#trunkSourceWebCoreinspectorInspectorInstrumentationcpp">trunk/Source/WebCore/inspector/InspectorInstrumentation.cpp</a></li>
<li><a href="#trunkSourceWebCoreinspectorInspectorInstrumentationh">trunk/Source/WebCore/inspector/InspectorInstrumentation.h</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceWebCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/ChangeLog (167570 => 167571)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/ChangeLog 2014-04-20 19:33:14 UTC (rev 167570)
+++ trunk/Source/WebCore/ChangeLog 2014-04-20 20:43:35 UTC (rev 167571)
</span><span class="lines">@@ -1,3 +1,64 @@
</span><ins>+2014-04-20 Benjamin Poulain <benjamin@webkit.org>
+
+ Rename the CSSSelector PseudoType to PseudoClassType
+ https://bugs.webkit.org/show_bug.cgi?id=131907
+
+ Reviewed by Andreas Kling.
+
+ Pseudo Elements and Page Pseudo Classes have been moved out of PseudoType in previous patches.
+ The remaining values in the PseudoType enumeration are the pseudo classes.
+
+ This patch is the final clean up, PseudoType is renamed to PseudoClassType.
+
+ * css/CSSGrammar.y.in:
+ * css/CSSParserValues.cpp:
+ (WebCore::CSSParserSelector::parsePseudoClassAndCompatibilityElementSelector):
+ * css/CSSParserValues.h:
+ (WebCore::CSSParserSelector::pseudoClassType):
+ (WebCore::CSSParserSelector::pseudoType): Deleted.
+ * css/CSSSelector.cpp:
+ (WebCore::CSSSelector::specificityForOneSelector):
+ (WebCore::appendPseudoClassFunctionTail):
+ (WebCore::CSSSelector::selectorText):
+ * css/CSSSelector.h:
+ (WebCore::CSSSelector::pseudoClassType):
+ (WebCore::CSSSelector::pseudoElementType):
+ (WebCore::CSSSelector::pagePseudoClassType):
+ (WebCore::pseudoClassIsRelativeToSiblings):
+ (WebCore::CSSSelector::isSiblingSelector):
+ (WebCore::CSSSelector::CSSSelector):
+ (WebCore::CSSSelector::pseudoType): Deleted.
+ * css/RuleSet.cpp:
+ (WebCore::RuleSet::findBestRuleSetAndAdd):
+ * css/SelectorChecker.cpp:
+ (WebCore::SelectorChecker::checkOne):
+ (WebCore::SelectorChecker::checkScrollbarPseudoClass):
+ (WebCore::SelectorChecker::determineLinkMatchType):
+ (WebCore::SelectorChecker::matchesFocusPseudoClass):
+ * css/SelectorChecker.h:
+ (WebCore::SelectorChecker::isCommonPseudoClassSelector):
+ * css/SelectorCheckerFastPath.cpp:
+ (WebCore::SelectorCheckerFastPath::commonPseudoClassSelectorMatches):
+ * css/SelectorPseudoClassAndCompatibilityElementMap.in:
+ * css/SelectorPseudoTypeMap.h:
+ * css/StyleResolver.cpp:
+ (WebCore::StyleResolver::styleForElement):
+ * css/makeSelectorPseudoClassAndCompatibilityElementMap.py:
+ (enumerablePseudoType):
+ * cssjit/SelectorCompiler.cpp:
+ (WebCore::SelectorCompiler::addPseudoClassType):
+ (WebCore::SelectorCompiler::SelectorCodeGenerator::SelectorCodeGenerator):
+ (WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementMatching):
+ (WebCore::SelectorCompiler::addPseudoType): Deleted.
+ * inspector/InspectorCSSAgent.cpp:
+ (WebCore::computePseudoClassMask):
+ (WebCore::InspectorCSSAgent::forcePseudoState):
+ * inspector/InspectorCSSAgent.h:
+ * inspector/InspectorInstrumentation.cpp:
+ (WebCore::InspectorInstrumentation::forcePseudoStateImpl):
+ * inspector/InspectorInstrumentation.h:
+ (WebCore::InspectorInstrumentation::forcePseudoState):
+
</ins><span class="cx"> 2014-04-19 Alexey Proskuryakov <ap@apple.com>
</span><span class="cx">
</span><span class="cx"> Crashes in HTMLFormElement::submit.
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSGrammaryin"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSGrammar.y.in (167570 => 167571)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSGrammar.y.in 2014-04-20 19:33:14 UTC (rev 167570)
+++ trunk/Source/WebCore/css/CSSGrammar.y.in 2014-04-20 20:43:35 UTC (rev 167571)
</span><span class="lines">@@ -1219,7 +1219,7 @@
</span><span class="cx"> selector->setMatch(CSSSelector::PseudoClass);
</span><span class="cx"> selector->adoptSelectorVector(*std::unique_ptr<Vector<std::unique_ptr<CSSParserSelector>>>($4));
</span><span class="cx"> selector->setPseudoClassValue($2);
</span><del>- if (selector->pseudoType() == CSSSelector::PseudoAny)
</del><ins>+ if (selector->pseudoClassType() == CSSSelector::PseudoClassAny)
</ins><span class="cx"> $$ = selector.release();
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="lines">@@ -1230,7 +1230,7 @@
</span><span class="cx"> selector->setMatch(CSSSelector::PseudoClass);
</span><span class="cx"> selector->setArgument($4);
</span><span class="cx"> selector->setPseudoClassValue($2);
</span><del>- if (selector->pseudoType() != CSSSelector::PseudoUnknown)
</del><ins>+ if (selector->pseudoClassType() != CSSSelector::PseudoClassUnknown)
</ins><span class="cx"> $$ = selector.release();
</span><span class="cx"> }
</span><span class="cx"> // used by :nth-*
</span><span class="lines">@@ -1240,7 +1240,7 @@
</span><span class="cx"> selector->setMatch(CSSSelector::PseudoClass);
</span><span class="cx"> selector->setArgument(AtomicString::number($4 * $5));
</span><span class="cx"> selector->setPseudoClassValue($2);
</span><del>- if (selector->pseudoType() != CSSSelector::PseudoUnknown)
</del><ins>+ if (selector->pseudoClassType() != CSSSelector::PseudoClassUnknown)
</ins><span class="cx"> $$ = selector.release();
</span><span class="cx"> }
</span><span class="cx"> // used by :nth-*(odd/even) and :lang
</span><span class="lines">@@ -1249,13 +1249,13 @@
</span><span class="cx"> selector->setMatch(CSSSelector::PseudoClass);
</span><span class="cx"> selector->setArgument($4);
</span><span class="cx"> selector->setPseudoClassValue($2);
</span><del>- CSSSelector::PseudoType type = selector->pseudoType();
- if (type == CSSSelector::PseudoUnknown)
</del><ins>+ CSSSelector::PseudoClassType type = selector->pseudoClassType();
+ if (type == CSSSelector::PseudoClassUnknown)
</ins><span class="cx"> selector = nullptr;
</span><del>- else if (type == CSSSelector::PseudoNthChild ||
- type == CSSSelector::PseudoNthOfType ||
- type == CSSSelector::PseudoNthLastChild ||
- type == CSSSelector::PseudoNthLastOfType) {
</del><ins>+ else if (type == CSSSelector::PseudoClassNthChild ||
+ type == CSSSelector::PseudoClassNthOfType ||
+ type == CSSSelector::PseudoClassNthLastChild ||
+ type == CSSSelector::PseudoClassNthLastOfType) {
</ins><span class="cx"> if (!isValidNthToken($4))
</span><span class="cx"> selector = nullptr;
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSParserValuescpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSParserValues.cpp (167570 => 167571)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSParserValues.cpp 2014-04-20 19:33:14 UTC (rev 167570)
+++ trunk/Source/WebCore/css/CSSParserValues.cpp 2014-04-20 20:43:35 UTC (rev 167571)
</span><span class="lines">@@ -206,7 +206,7 @@
</span><span class="cx"> CSSParserSelector* CSSParserSelector::parsePseudoClassAndCompatibilityElementSelector(CSSParserString& pseudoTypeString)
</span><span class="cx"> {
</span><span class="cx"> PseudoClassOrCompatibilityPseudoElement pseudoType = parsePseudoClassAndCompatibilityElementString(pseudoTypeString);
</span><del>- if (pseudoType.pseudoClass != CSSSelector::PseudoUnknown) {
</del><ins>+ if (pseudoType.pseudoClass != CSSSelector::PseudoClassUnknown) {
</ins><span class="cx"> auto selector = std::make_unique<CSSParserSelector>();
</span><span class="cx"> selector->m_selector->m_match = CSSSelector::PseudoClass;
</span><span class="cx"> selector->m_selector->m_pseudoType = pseudoType.pseudoClass;
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSParserValuesh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSParserValues.h (167570 => 167571)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSParserValues.h 2014-04-20 19:33:14 UTC (rev 167570)
+++ trunk/Source/WebCore/css/CSSParserValues.h 2014-04-20 20:43:35 UTC (rev 167571)
</span><span class="lines">@@ -197,7 +197,7 @@
</span><span class="cx"> void adoptSelectorVector(Vector<std::unique_ptr<CSSParserSelector>>& selectorVector);
</span><span class="cx">
</span><span class="cx"> void setPseudoClassValue(const CSSParserString& pseudoClassString);
</span><del>- CSSSelector::PseudoType pseudoType() const { return m_selector->pseudoType(); }
</del><ins>+ CSSSelector::PseudoClassType pseudoClassType() const { return m_selector->pseudoClassType(); }
</ins><span class="cx"> bool isCustomPseudoElement() const { return m_selector->isCustomPseudoElement(); }
</span><span class="cx">
</span><span class="cx"> bool isPseudoElementCueFunction() const
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSSelectorcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSSelector.cpp (167570 => 167571)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSSelector.cpp 2014-04-20 19:33:14 UTC (rev 167570)
+++ trunk/Source/WebCore/css/CSSSelector.cpp 2014-04-20 20:43:35 UTC (rev 167571)
</span><span class="lines">@@ -92,7 +92,7 @@
</span><span class="cx"> case PseudoClass:
</span><span class="cx"> // FIXME: PsuedoAny should base the specificity on the sub-selectors.
</span><span class="cx"> // See http://lists.w3.org/Archives/Public/www-style/2010Sep/0530.html
</span><del>- if (pseudoType() == PseudoNot && selectorList())
</del><ins>+ if (pseudoClassType() == PseudoClassNot && selectorList())
</ins><span class="cx"> return selectorList()->first()->specificityForOneSelector();
</span><span class="cx"> FALLTHROUGH;
</span><span class="cx"> case Exact:
</span><span class="lines">@@ -230,12 +230,12 @@
</span><span class="cx">
</span><span class="cx"> static void appendPseudoClassFunctionTail(StringBuilder& str, const CSSSelector* selector)
</span><span class="cx"> {
</span><del>- switch (selector->pseudoType()) {
- case CSSSelector::PseudoLang:
- case CSSSelector::PseudoNthChild:
- case CSSSelector::PseudoNthLastChild:
- case CSSSelector::PseudoNthOfType:
- case CSSSelector::PseudoNthLastOfType:
</del><ins>+ switch (selector->pseudoClassType()) {
+ case CSSSelector::PseudoClassLang:
+ case CSSSelector::PseudoClassNthChild:
+ case CSSSelector::PseudoClassNthLastChild:
+ case CSSSelector::PseudoClassNthOfType:
+ case CSSSelector::PseudoClassNthLastOfType:
</ins><span class="cx"> str.append(selector->argument());
</span><span class="cx"> str.append(')');
</span><span class="cx"> break;
</span><span class="lines">@@ -268,13 +268,13 @@
</span><span class="cx"> str.append('.');
</span><span class="cx"> serializeIdentifier(cs->value(), str);
</span><span class="cx"> } else if (cs->m_match == CSSSelector::PseudoClass) {
</span><del>- switch (cs->pseudoType()) {
</del><ins>+ switch (cs->pseudoClassType()) {
</ins><span class="cx"> #if ENABLE(FULLSCREEN_API)
</span><del>- case CSSSelector::PseudoAnimatingFullScreenTransition:
</del><ins>+ case CSSSelector::PseudoClassAnimatingFullScreenTransition:
</ins><span class="cx"> str.appendLiteral(":-webkit-animating-full-screen-transition");
</span><span class="cx"> break;
</span><span class="cx"> #endif
</span><del>- case CSSSelector::PseudoAny: {
</del><ins>+ case CSSSelector::PseudoClassAny: {
</ins><span class="cx"> str.appendLiteral(":-webkit-any(");
</span><span class="cx"> const CSSSelector* firstSubSelector = cs->selectorList()->first();
</span><span class="cx"> for (const CSSSelector* subSelector = firstSubSelector; subSelector; subSelector = CSSSelectorList::next(subSelector)) {
</span><span class="lines">@@ -285,180 +285,180 @@
</span><span class="cx"> str.append(')');
</span><span class="cx"> break;
</span><span class="cx"> }
</span><del>- case CSSSelector::PseudoAnyLink:
</del><ins>+ case CSSSelector::PseudoClassAnyLink:
</ins><span class="cx"> str.appendLiteral(":-webkit-any-link");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoAutofill:
</del><ins>+ case CSSSelector::PseudoClassAutofill:
</ins><span class="cx"> str.appendLiteral(":-webkit-autofill");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoDrag:
</del><ins>+ case CSSSelector::PseudoClassDrag:
</ins><span class="cx"> str.appendLiteral(":-webkit-drag");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoFullPageMedia:
</del><ins>+ case CSSSelector::PseudoClassFullPageMedia:
</ins><span class="cx"> str.appendLiteral(":-webkit-full-page-media");
</span><span class="cx"> break;
</span><span class="cx"> #if ENABLE(FULLSCREEN_API)
</span><del>- case CSSSelector::PseudoFullScreen:
</del><ins>+ case CSSSelector::PseudoClassFullScreen:
</ins><span class="cx"> str.appendLiteral(":-webkit-full-screen");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoFullScreenAncestor:
</del><ins>+ case CSSSelector::PseudoClassFullScreenAncestor:
</ins><span class="cx"> str.appendLiteral(":-webkit-full-screen-ancestor");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoFullScreenDocument:
</del><ins>+ case CSSSelector::PseudoClassFullScreenDocument:
</ins><span class="cx"> str.appendLiteral(":-webkit-full-screen-document");
</span><span class="cx"> break;
</span><span class="cx"> #endif
</span><del>- case CSSSelector::PseudoActive:
</del><ins>+ case CSSSelector::PseudoClassActive:
</ins><span class="cx"> str.appendLiteral(":active");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoChecked:
</del><ins>+ case CSSSelector::PseudoClassChecked:
</ins><span class="cx"> str.appendLiteral(":checked");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoCornerPresent:
</del><ins>+ case CSSSelector::PseudoClassCornerPresent:
</ins><span class="cx"> str.appendLiteral(":corner-present");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoDecrement:
</del><ins>+ case CSSSelector::PseudoClassDecrement:
</ins><span class="cx"> str.appendLiteral(":decrement");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoDefault:
</del><ins>+ case CSSSelector::PseudoClassDefault:
</ins><span class="cx"> str.appendLiteral(":default");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoDisabled:
</del><ins>+ case CSSSelector::PseudoClassDisabled:
</ins><span class="cx"> str.appendLiteral(":disabled");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoDoubleButton:
</del><ins>+ case CSSSelector::PseudoClassDoubleButton:
</ins><span class="cx"> str.appendLiteral(":double-button");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoEmpty:
</del><ins>+ case CSSSelector::PseudoClassEmpty:
</ins><span class="cx"> str.appendLiteral(":empty");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoEnabled:
</del><ins>+ case CSSSelector::PseudoClassEnabled:
</ins><span class="cx"> str.appendLiteral(":enabled");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoEnd:
</del><ins>+ case CSSSelector::PseudoClassEnd:
</ins><span class="cx"> str.appendLiteral(":end");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoFirstChild:
</del><ins>+ case CSSSelector::PseudoClassFirstChild:
</ins><span class="cx"> str.appendLiteral(":first-child");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoFirstOfType:
</del><ins>+ case CSSSelector::PseudoClassFirstOfType:
</ins><span class="cx"> str.appendLiteral(":first-of-type");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoFocus:
</del><ins>+ case CSSSelector::PseudoClassFocus:
</ins><span class="cx"> str.appendLiteral(":focus");
</span><span class="cx"> break;
</span><span class="cx"> #if ENABLE(VIDEO_TRACK)
</span><del>- case CSSSelector::PseudoFuture:
</del><ins>+ case CSSSelector::PseudoClassFuture:
</ins><span class="cx"> str.appendLiteral(":future");
</span><span class="cx"> break;
</span><span class="cx"> #endif
</span><del>- case CSSSelector::PseudoHorizontal:
</del><ins>+ case CSSSelector::PseudoClassHorizontal:
</ins><span class="cx"> str.appendLiteral(":horizontal");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoHover:
</del><ins>+ case CSSSelector::PseudoClassHover:
</ins><span class="cx"> str.appendLiteral(":hover");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoInRange:
</del><ins>+ case CSSSelector::PseudoClassInRange:
</ins><span class="cx"> str.appendLiteral(":in-range");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoIncrement:
</del><ins>+ case CSSSelector::PseudoClassIncrement:
</ins><span class="cx"> str.appendLiteral(":increment");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoIndeterminate:
</del><ins>+ case CSSSelector::PseudoClassIndeterminate:
</ins><span class="cx"> str.appendLiteral(":indeterminate");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoInvalid:
</del><ins>+ case CSSSelector::PseudoClassInvalid:
</ins><span class="cx"> str.appendLiteral(":invalid");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoLang:
</del><ins>+ case CSSSelector::PseudoClassLang:
</ins><span class="cx"> str.appendLiteral(":lang(");
</span><span class="cx"> appendPseudoClassFunctionTail(str, cs);
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoLastChild:
</del><ins>+ case CSSSelector::PseudoClassLastChild:
</ins><span class="cx"> str.appendLiteral(":last-child");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoLastOfType:
</del><ins>+ case CSSSelector::PseudoClassLastOfType:
</ins><span class="cx"> str.appendLiteral(":last-of-type");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoLink:
</del><ins>+ case CSSSelector::PseudoClassLink:
</ins><span class="cx"> str.appendLiteral(":link");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoNoButton:
</del><ins>+ case CSSSelector::PseudoClassNoButton:
</ins><span class="cx"> str.appendLiteral(":no-button");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoNot:
</del><ins>+ case CSSSelector::PseudoClassNot:
</ins><span class="cx"> str.appendLiteral(":not(");
</span><span class="cx"> if (const CSSSelectorList* selectorList = cs->selectorList())
</span><span class="cx"> str.append(selectorList->first()->selectorText());
</span><span class="cx"> str.append(')');
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoNthChild:
</del><ins>+ case CSSSelector::PseudoClassNthChild:
</ins><span class="cx"> str.appendLiteral(":nth-child(");
</span><span class="cx"> appendPseudoClassFunctionTail(str, cs);
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoNthLastChild:
</del><ins>+ case CSSSelector::PseudoClassNthLastChild:
</ins><span class="cx"> str.appendLiteral(":nth-last-child(");
</span><span class="cx"> appendPseudoClassFunctionTail(str, cs);
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoNthLastOfType:
</del><ins>+ case CSSSelector::PseudoClassNthLastOfType:
</ins><span class="cx"> str.appendLiteral(":nth-last-of-type(");
</span><span class="cx"> appendPseudoClassFunctionTail(str, cs);
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoNthOfType:
</del><ins>+ case CSSSelector::PseudoClassNthOfType:
</ins><span class="cx"> str.appendLiteral(":nth-of-type(");
</span><span class="cx"> appendPseudoClassFunctionTail(str, cs);
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoOnlyChild:
</del><ins>+ case CSSSelector::PseudoClassOnlyChild:
</ins><span class="cx"> str.appendLiteral(":only-child");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoOnlyOfType:
</del><ins>+ case CSSSelector::PseudoClassOnlyOfType:
</ins><span class="cx"> str.appendLiteral(":only-of-type");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoOptional:
</del><ins>+ case CSSSelector::PseudoClassOptional:
</ins><span class="cx"> str.appendLiteral(":optional");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoOutOfRange:
</del><ins>+ case CSSSelector::PseudoClassOutOfRange:
</ins><span class="cx"> str.appendLiteral(":out-of-range");
</span><span class="cx"> break;
</span><span class="cx"> #if ENABLE(VIDEO_TRACK)
</span><del>- case CSSSelector::PseudoPast:
</del><ins>+ case CSSSelector::PseudoClassPast:
</ins><span class="cx"> str.appendLiteral(":past");
</span><span class="cx"> break;
</span><span class="cx"> #endif
</span><del>- case CSSSelector::PseudoReadOnly:
</del><ins>+ case CSSSelector::PseudoClassReadOnly:
</ins><span class="cx"> str.appendLiteral(":read-only");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoReadWrite:
</del><ins>+ case CSSSelector::PseudoClassReadWrite:
</ins><span class="cx"> str.appendLiteral(":read-write");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoRequired:
</del><ins>+ case CSSSelector::PseudoClassRequired:
</ins><span class="cx"> str.appendLiteral(":required");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoRoot:
</del><ins>+ case CSSSelector::PseudoClassRoot:
</ins><span class="cx"> str.appendLiteral(":root");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoScope:
</del><ins>+ case CSSSelector::PseudoClassScope:
</ins><span class="cx"> str.appendLiteral(":scope");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoSingleButton:
</del><ins>+ case CSSSelector::PseudoClassSingleButton:
</ins><span class="cx"> str.appendLiteral(":single-button");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoStart:
</del><ins>+ case CSSSelector::PseudoClassStart:
</ins><span class="cx"> str.appendLiteral(":start");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoTarget:
</del><ins>+ case CSSSelector::PseudoClassTarget:
</ins><span class="cx"> str.appendLiteral(":target");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoValid:
</del><ins>+ case CSSSelector::PseudoClassValid:
</ins><span class="cx"> str.appendLiteral(":valid");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoVertical:
</del><ins>+ case CSSSelector::PseudoClassVertical:
</ins><span class="cx"> str.appendLiteral(":vertical");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoVisited:
</del><ins>+ case CSSSelector::PseudoClassVisited:
</ins><span class="cx"> str.appendLiteral(":visited");
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoWindowInactive:
</del><ins>+ case CSSSelector::PseudoClassWindowInactive:
</ins><span class="cx"> str.appendLiteral(":window-inactive");
</span><span class="cx"> break;
</span><span class="cx"> default:
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSSelectorh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSSelector.h (167570 => 167571)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSSelector.h 2014-04-20 19:33:14 UTC (rev 167570)
+++ trunk/Source/WebCore/css/CSSSelector.h 2014-04-20 20:43:35 UTC (rev 167571)
</span><span class="lines">@@ -78,67 +78,67 @@
</span><span class="cx"> ShadowDescendant,
</span><span class="cx"> };
</span><span class="cx">
</span><del>- enum PseudoType {
- PseudoUnknown = 0,
- PseudoEmpty,
- PseudoFirstChild,
- PseudoFirstOfType,
- PseudoLastChild,
- PseudoLastOfType,
- PseudoOnlyChild,
- PseudoOnlyOfType,
- PseudoNthChild,
- PseudoNthOfType,
- PseudoNthLastChild,
- PseudoNthLastOfType,
- PseudoLink,
- PseudoVisited,
- PseudoAny,
- PseudoAnyLink,
- PseudoAutofill,
- PseudoHover,
- PseudoDrag,
- PseudoFocus,
- PseudoActive,
- PseudoChecked,
- PseudoEnabled,
- PseudoFullPageMedia,
- PseudoDefault,
- PseudoDisabled,
- PseudoOptional,
- PseudoRequired,
- PseudoReadOnly,
- PseudoReadWrite,
- PseudoValid,
- PseudoInvalid,
- PseudoIndeterminate,
- PseudoTarget,
- PseudoLang,
- PseudoNot,
- PseudoRoot,
- PseudoScope,
- PseudoWindowInactive,
- PseudoCornerPresent,
- PseudoDecrement,
- PseudoIncrement,
- PseudoHorizontal,
- PseudoVertical,
- PseudoStart,
- PseudoEnd,
- PseudoDoubleButton,
- PseudoSingleButton,
- PseudoNoButton,
</del><ins>+ enum PseudoClassType {
+ PseudoClassUnknown = 0,
+ PseudoClassEmpty,
+ PseudoClassFirstChild,
+ PseudoClassFirstOfType,
+ PseudoClassLastChild,
+ PseudoClassLastOfType,
+ PseudoClassOnlyChild,
+ PseudoClassOnlyOfType,
+ PseudoClassNthChild,
+ PseudoClassNthOfType,
+ PseudoClassNthLastChild,
+ PseudoClassNthLastOfType,
+ PseudoClassLink,
+ PseudoClassVisited,
+ PseudoClassAny,
+ PseudoClassAnyLink,
+ PseudoClassAutofill,
+ PseudoClassHover,
+ PseudoClassDrag,
+ PseudoClassFocus,
+ PseudoClassActive,
+ PseudoClassChecked,
+ PseudoClassEnabled,
+ PseudoClassFullPageMedia,
+ PseudoClassDefault,
+ PseudoClassDisabled,
+ PseudoClassOptional,
+ PseudoClassRequired,
+ PseudoClassReadOnly,
+ PseudoClassReadWrite,
+ PseudoClassValid,
+ PseudoClassInvalid,
+ PseudoClassIndeterminate,
+ PseudoClassTarget,
+ PseudoClassLang,
+ PseudoClassNot,
+ PseudoClassRoot,
+ PseudoClassScope,
+ PseudoClassWindowInactive,
+ PseudoClassCornerPresent,
+ PseudoClassDecrement,
+ PseudoClassIncrement,
+ PseudoClassHorizontal,
+ PseudoClassVertical,
+ PseudoClassStart,
+ PseudoClassEnd,
+ PseudoClassDoubleButton,
+ PseudoClassSingleButton,
+ PseudoClassNoButton,
</ins><span class="cx"> #if ENABLE(FULLSCREEN_API)
</span><del>- PseudoFullScreen,
- PseudoFullScreenDocument,
- PseudoFullScreenAncestor,
- PseudoAnimatingFullScreenTransition,
</del><ins>+ PseudoClassFullScreen,
+ PseudoClassFullScreenDocument,
+ PseudoClassFullScreenAncestor,
+ PseudoClassAnimatingFullScreenTransition,
</ins><span class="cx"> #endif
</span><del>- PseudoInRange,
- PseudoOutOfRange,
</del><ins>+ PseudoClassInRange,
+ PseudoClassOutOfRange,
</ins><span class="cx"> #if ENABLE(VIDEO_TRACK)
</span><del>- PseudoFuture,
- PseudoPast,
</del><ins>+ PseudoClassFuture,
+ PseudoClassPast,
</ins><span class="cx"> #endif
</span><span class="cx"> };
</span><span class="cx">
</span><span class="lines">@@ -188,12 +188,6 @@
</span><span class="cx"> RightBottomMarginBox,
</span><span class="cx"> };
</span><span class="cx">
</span><del>- PseudoType pseudoType() const
- {
- ASSERT(m_match == PseudoClass);
- return static_cast<PseudoType>(m_pseudoType);
- }
-
</del><span class="cx"> static PseudoElementType parsePseudoElementType(const String&);
</span><span class="cx"> static PseudoId pseudoId(PseudoElementType);
</span><span class="cx">
</span><span class="lines">@@ -220,9 +214,24 @@
</span><span class="cx"> int nthA() const;
</span><span class="cx"> int nthB() const;
</span><span class="cx">
</span><del>- PseudoElementType pseudoElementType() const { ASSERT(m_match == PseudoElement); return static_cast<PseudoElementType>(m_pseudoType); }
- PagePseudoClassType pagePseudoClassType() const { ASSERT(m_match == PagePseudoClass); return static_cast<PagePseudoClassType>(m_pseudoType); }
</del><ins>+ PseudoClassType pseudoClassType() const
+ {
+ ASSERT(m_match == PseudoClass);
+ return static_cast<PseudoClassType>(m_pseudoType);
+ }
</ins><span class="cx">
</span><ins>+ PseudoElementType pseudoElementType() const
+ {
+ ASSERT(m_match == PseudoElement);
+ return static_cast<PseudoElementType>(m_pseudoType);
+ }
+
+ PagePseudoClassType pagePseudoClassType() const
+ {
+ ASSERT(m_match == PagePseudoClass);
+ return static_cast<PagePseudoClassType>(m_pseudoType);
+ }
+
</ins><span class="cx"> bool matchesPseudoElement() const;
</span><span class="cx"> bool isUnknownPseudoElement() const;
</span><span class="cx"> bool isCustomPseudoElement() const;
</span><span class="lines">@@ -316,26 +325,26 @@
</span><span class="cx"> return m_match == PseudoElement && (m_pseudoType == PseudoElementUserAgentCustom || m_pseudoType == PseudoElementWebKitCustom);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static inline bool pseudoClassIsRelativeToSiblings(CSSSelector::PseudoType type)
</del><ins>+static inline bool pseudoClassIsRelativeToSiblings(CSSSelector::PseudoClassType type)
</ins><span class="cx"> {
</span><del>- return type == CSSSelector::PseudoEmpty
- || type == CSSSelector::PseudoFirstChild
- || type == CSSSelector::PseudoFirstOfType
- || type == CSSSelector::PseudoLastChild
- || type == CSSSelector::PseudoLastOfType
- || type == CSSSelector::PseudoOnlyChild
- || type == CSSSelector::PseudoOnlyOfType
- || type == CSSSelector::PseudoNthChild
- || type == CSSSelector::PseudoNthOfType
- || type == CSSSelector::PseudoNthLastChild
- || type == CSSSelector::PseudoNthLastOfType;
</del><ins>+ return type == CSSSelector::PseudoClassEmpty
+ || type == CSSSelector::PseudoClassFirstChild
+ || type == CSSSelector::PseudoClassFirstOfType
+ || type == CSSSelector::PseudoClassLastChild
+ || type == CSSSelector::PseudoClassLastOfType
+ || type == CSSSelector::PseudoClassOnlyChild
+ || type == CSSSelector::PseudoClassOnlyOfType
+ || type == CSSSelector::PseudoClassNthChild
+ || type == CSSSelector::PseudoClassNthOfType
+ || type == CSSSelector::PseudoClassNthLastChild
+ || type == CSSSelector::PseudoClassNthLastOfType;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> inline bool CSSSelector::isSiblingSelector() const
</span><span class="cx"> {
</span><span class="cx"> return m_relation == DirectAdjacent
</span><span class="cx"> || m_relation == IndirectAdjacent
</span><del>- || (m_match == CSSSelector::PseudoClass && pseudoClassIsRelativeToSiblings(pseudoType()));
</del><ins>+ || (m_match == CSSSelector::PseudoClass && pseudoClassIsRelativeToSiblings(pseudoClassType()));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> inline bool CSSSelector::isAttributeSelector() const
</span><span class="lines">@@ -369,7 +378,7 @@
</span><span class="cx"> inline CSSSelector::CSSSelector()
</span><span class="cx"> : m_relation(Descendant)
</span><span class="cx"> , m_match(Unknown)
</span><del>- , m_pseudoType(PseudoUnknown)
</del><ins>+ , m_pseudoType(0)
</ins><span class="cx"> , m_parsedNth(false)
</span><span class="cx"> , m_isLastInSelectorList(false)
</span><span class="cx"> , m_isLastInTagHistory(true)
</span><span class="lines">@@ -382,7 +391,7 @@
</span><span class="cx"> inline CSSSelector::CSSSelector(const QualifiedName& tagQName, bool tagIsForNamespaceRule)
</span><span class="cx"> : m_relation(Descendant)
</span><span class="cx"> , m_match(Tag)
</span><del>- , m_pseudoType(PseudoUnknown)
</del><ins>+ , m_pseudoType(0)
</ins><span class="cx"> , m_parsedNth(false)
</span><span class="cx"> , m_isLastInSelectorList(false)
</span><span class="cx"> , m_isLastInTagHistory(true)
</span></span></pre></div>
<a id="trunkSourceWebCorecssRuleSetcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/RuleSet.cpp (167570 => 167571)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/RuleSet.cpp 2014-04-20 19:33:14 UTC (rev 167570)
+++ trunk/Source/WebCore/css/RuleSet.cpp 2014-04-20 20:43:35 UTC (rev 167571)
</span><span class="lines">@@ -198,13 +198,13 @@
</span><span class="cx"> }
</span><span class="cx"> #endif
</span><span class="cx"> if (SelectorChecker::isCommonPseudoClassSelector(component)) {
</span><del>- switch (component->pseudoType()) {
- case CSSSelector::PseudoLink:
- case CSSSelector::PseudoVisited:
- case CSSSelector::PseudoAnyLink:
</del><ins>+ switch (component->pseudoClassType()) {
+ case CSSSelector::PseudoClassLink:
+ case CSSSelector::PseudoClassVisited:
+ case CSSSelector::PseudoClassAnyLink:
</ins><span class="cx"> m_linkPseudoClassRules.append(ruleData);
</span><span class="cx"> return true;
</span><del>- case CSSSelector::PseudoFocus:
</del><ins>+ case CSSSelector::PseudoClassFocus:
</ins><span class="cx"> m_focusPseudoClassRules.append(ruleData);
</span><span class="cx"> return true;
</span><span class="cx"> default:
</span></span></pre></div>
<a id="trunkSourceWebCorecssSelectorCheckercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/SelectorChecker.cpp (167570 => 167571)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/SelectorChecker.cpp 2014-04-20 19:33:14 UTC (rev 167570)
+++ trunk/Source/WebCore/css/SelectorChecker.cpp 2014-04-20 20:43:35 UTC (rev 167571)
</span><span class="lines">@@ -385,7 +385,7 @@
</span><span class="cx">
</span><span class="cx"> if (selector->m_match == CSSSelector::PseudoClass) {
</span><span class="cx"> // Handle :not up front.
</span><del>- if (selector->pseudoType() == CSSSelector::PseudoNot) {
</del><ins>+ if (selector->pseudoClassType() == CSSSelector::PseudoClassNot) {
</ins><span class="cx"> const CSSSelectorList* selectorList = selector->selectorList();
</span><span class="cx">
</span><span class="cx"> // FIXME: We probably should fix the parser and make it never produce :not rules with missing selector list.
</span><span class="lines">@@ -399,9 +399,9 @@
</span><span class="cx"> // :not cannot nest. I don't really know why this is a
</span><span class="cx"> // restriction in CSS3, but it is, so let's honor it.
</span><span class="cx"> // the parser enforces that this never occurs
</span><del>- ASSERT(subContext.selector->pseudoType() != CSSSelector::PseudoNot);
</del><ins>+ ASSERT(subContext.selector->pseudoClassType() != CSSSelector::PseudoClassNot);
</ins><span class="cx"> // We select between :visited and :link when applying. We don't know which one applied (or not) yet.
</span><del>- if (subContext.selector->pseudoType() == CSSSelector::PseudoVisited || (subContext.selector->pseudoType() == CSSSelector::PseudoLink && subContext.visitedMatchType == VisitedMatchEnabled))
</del><ins>+ if (subContext.selector->pseudoClassType() == CSSSelector::PseudoClassVisited || (subContext.selector->pseudoClassType() == CSSSelector::PseudoClassLink && subContext.visitedMatchType == VisitedMatchEnabled))
</ins><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx"> if (!checkOne(subContext))
</span><span class="lines">@@ -412,16 +412,16 @@
</span><span class="cx"> // (since there are no elements involved).
</span><span class="cx"> return checkScrollbarPseudoClass(context, &element->document(), selector);
</span><span class="cx"> } else if (context.hasSelectionPseudo) {
</span><del>- if (selector->pseudoType() == CSSSelector::PseudoWindowInactive)
</del><ins>+ if (selector->pseudoClassType() == CSSSelector::PseudoClassWindowInactive)
</ins><span class="cx"> return !element->document().page()->focusController().isActive();
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // Normal element pseudo class checking.
</span><del>- switch (selector->pseudoType()) {
</del><ins>+ switch (selector->pseudoClassType()) {
</ins><span class="cx"> // Pseudo classes:
</span><del>- case CSSSelector::PseudoNot:
</del><ins>+ case CSSSelector::PseudoClassNot:
</ins><span class="cx"> break; // Already handled up above.
</span><del>- case CSSSelector::PseudoEmpty:
</del><ins>+ case CSSSelector::PseudoClassEmpty:
</ins><span class="cx"> {
</span><span class="cx"> bool result = true;
</span><span class="cx"> for (Node* n = element->firstChild(); n; n = n->nextSibling()) {
</span><span class="lines">@@ -446,7 +446,7 @@
</span><span class="cx"> }
</span><span class="cx"> return result;
</span><span class="cx"> }
</span><del>- case CSSSelector::PseudoFirstChild:
</del><ins>+ case CSSSelector::PseudoClassFirstChild:
</ins><span class="cx"> // first-child matches the first child that is an element
</span><span class="cx"> if (Element* parentElement = element->parentElement()) {
</span><span class="cx"> bool result = isFirstChildElement(element);
</span><span class="lines">@@ -459,7 +459,7 @@
</span><span class="cx"> return result;
</span><span class="cx"> }
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoFirstOfType:
</del><ins>+ case CSSSelector::PseudoClassFirstOfType:
</ins><span class="cx"> // first-of-type matches the first element of its type
</span><span class="cx"> if (Element* parentElement = element->parentElement()) {
</span><span class="cx"> bool result = isFirstOfType(element, element->tagQName());
</span><span class="lines">@@ -468,7 +468,7 @@
</span><span class="cx"> return result;
</span><span class="cx"> }
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoLastChild:
</del><ins>+ case CSSSelector::PseudoClassLastChild:
</ins><span class="cx"> // last-child matches the last child that is an element
</span><span class="cx"> if (Element* parentElement = element->parentElement()) {
</span><span class="cx"> bool result = parentElement->isFinishedParsingChildren() && isLastChildElement(element);
</span><span class="lines">@@ -481,7 +481,7 @@
</span><span class="cx"> return result;
</span><span class="cx"> }
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoLastOfType:
</del><ins>+ case CSSSelector::PseudoClassLastOfType:
</ins><span class="cx"> // last-of-type matches the last element of its type
</span><span class="cx"> if (Element* parentElement = element->parentElement()) {
</span><span class="cx"> if (m_mode == ResolvingStyle)
</span><span class="lines">@@ -491,7 +491,7 @@
</span><span class="cx"> return isLastOfType(element, element->tagQName());
</span><span class="cx"> }
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoOnlyChild:
</del><ins>+ case CSSSelector::PseudoClassOnlyChild:
</ins><span class="cx"> if (Element* parentElement = element->parentElement()) {
</span><span class="cx"> bool firstChild = isFirstChildElement(element);
</span><span class="cx"> bool onlyChild = firstChild && parentElement->isFinishedParsingChildren() && isLastChildElement(element);
</span><span class="lines">@@ -507,7 +507,7 @@
</span><span class="cx"> return onlyChild;
</span><span class="cx"> }
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoOnlyOfType:
</del><ins>+ case CSSSelector::PseudoClassOnlyOfType:
</ins><span class="cx"> // FIXME: This selector is very slow.
</span><span class="cx"> if (Element* parentElement = element->parentElement()) {
</span><span class="cx"> if (m_mode == ResolvingStyle) {
</span><span class="lines">@@ -519,7 +519,7 @@
</span><span class="cx"> return isFirstOfType(element, element->tagQName()) && isLastOfType(element, element->tagQName());
</span><span class="cx"> }
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoNthChild:
</del><ins>+ case CSSSelector::PseudoClassNthChild:
</ins><span class="cx"> if (!selector->parseNth())
</span><span class="cx"> break;
</span><span class="cx"> if (Element* parentElement = element->parentElement()) {
</span><span class="lines">@@ -536,7 +536,7 @@
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoNthOfType:
</del><ins>+ case CSSSelector::PseudoClassNthOfType:
</ins><span class="cx"> if (!selector->parseNth())
</span><span class="cx"> break;
</span><span class="cx"> if (Element* parentElement = element->parentElement()) {
</span><span class="lines">@@ -548,7 +548,7 @@
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoNthLastChild:
</del><ins>+ case CSSSelector::PseudoClassNthLastChild:
</ins><span class="cx"> if (!selector->parseNth())
</span><span class="cx"> break;
</span><span class="cx"> if (Element* parentElement = element->parentElement()) {
</span><span class="lines">@@ -561,7 +561,7 @@
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoNthLastOfType:
</del><ins>+ case CSSSelector::PseudoClassNthLastOfType:
</ins><span class="cx"> if (!selector->parseNth())
</span><span class="cx"> break;
</span><span class="cx"> if (Element* parentElement = element->parentElement()) {
</span><span class="lines">@@ -575,11 +575,11 @@
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoTarget:
</del><ins>+ case CSSSelector::PseudoClassTarget:
</ins><span class="cx"> if (element == element->document().cssTarget())
</span><span class="cx"> return true;
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoAny:
</del><ins>+ case CSSSelector::PseudoClassAny:
</ins><span class="cx"> {
</span><span class="cx"> SelectorCheckingContext subContext(context);
</span><span class="cx"> subContext.isSubSelector = true;
</span><span class="lines">@@ -590,16 +590,16 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoAutofill:
</del><ins>+ case CSSSelector::PseudoClassAutofill:
</ins><span class="cx"> return isAutofilled(element);
</span><del>- case CSSSelector::PseudoAnyLink:
- case CSSSelector::PseudoLink:
</del><ins>+ case CSSSelector::PseudoClassAnyLink:
+ case CSSSelector::PseudoClassLink:
</ins><span class="cx"> // :visited and :link matches are separated later when applying the style. Here both classes match all links...
</span><span class="cx"> return element->isLink();
</span><del>- case CSSSelector::PseudoVisited:
</del><ins>+ case CSSSelector::PseudoClassVisited:
</ins><span class="cx"> // ...except if :visited matching is disabled for ancestor/sibling matching.
</span><span class="cx"> return element->isLink() && context.visitedMatchType == VisitedMatchEnabled;
</span><del>- case CSSSelector::PseudoDrag:
</del><ins>+ case CSSSelector::PseudoClassDrag:
</ins><span class="cx"> if (m_mode == ResolvingStyle) {
</span><span class="cx"> if (context.elementStyle)
</span><span class="cx"> context.elementStyle->setAffectedByDrag();
</span><span class="lines">@@ -609,9 +609,9 @@
</span><span class="cx"> if (element->renderer() && element->renderer()->isDragging())
</span><span class="cx"> return true;
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoFocus:
</del><ins>+ case CSSSelector::PseudoClassFocus:
</ins><span class="cx"> return matchesFocusPseudoClass(element);
</span><del>- case CSSSelector::PseudoHover:
</del><ins>+ case CSSSelector::PseudoClassHover:
</ins><span class="cx"> // If we're in quirks mode, then hover should never match anchors with no
</span><span class="cx"> // href and *:hover should not match anything. This is important for sites like wsj.com.
</span><span class="cx"> if (m_strictParsing || context.isSubSelector || element->isLink()) {
</span><span class="lines">@@ -621,11 +621,11 @@
</span><span class="cx"> else
</span><span class="cx"> element->setChildrenAffectedByHover();
</span><span class="cx"> }
</span><del>- if (element->hovered() || InspectorInstrumentation::forcePseudoState(element, CSSSelector::PseudoHover))
</del><ins>+ if (element->hovered() || InspectorInstrumentation::forcePseudoState(element, CSSSelector::PseudoClassHover))
</ins><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoActive:
</del><ins>+ case CSSSelector::PseudoClassActive:
</ins><span class="cx"> // If we're in quirks mode, then :active should never match anchors with no
</span><span class="cx"> // href and *:active should not match anything.
</span><span class="cx"> if (m_strictParsing || context.isSubSelector || element->isLink()) {
</span><span class="lines">@@ -635,39 +635,39 @@
</span><span class="cx"> else
</span><span class="cx"> element->setChildrenAffectedByActive();
</span><span class="cx"> }
</span><del>- if (element->active() || InspectorInstrumentation::forcePseudoState(element, CSSSelector::PseudoActive))
</del><ins>+ if (element->active() || InspectorInstrumentation::forcePseudoState(element, CSSSelector::PseudoClassActive))
</ins><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoEnabled:
</del><ins>+ case CSSSelector::PseudoClassEnabled:
</ins><span class="cx"> return isEnabled(element);
</span><del>- case CSSSelector::PseudoFullPageMedia:
</del><ins>+ case CSSSelector::PseudoClassFullPageMedia:
</ins><span class="cx"> return element->document().isMediaDocument();
</span><del>- case CSSSelector::PseudoDefault:
</del><ins>+ case CSSSelector::PseudoClassDefault:
</ins><span class="cx"> return isDefaultButtonForForm(element);
</span><del>- case CSSSelector::PseudoDisabled:
</del><ins>+ case CSSSelector::PseudoClassDisabled:
</ins><span class="cx"> return isDisabled(element);
</span><del>- case CSSSelector::PseudoReadOnly:
</del><ins>+ case CSSSelector::PseudoClassReadOnly:
</ins><span class="cx"> return matchesReadOnlyPseudoClass(element);
</span><del>- case CSSSelector::PseudoReadWrite:
</del><ins>+ case CSSSelector::PseudoClassReadWrite:
</ins><span class="cx"> return matchesReadWritePseudoClass(element);
</span><del>- case CSSSelector::PseudoOptional:
</del><ins>+ case CSSSelector::PseudoClassOptional:
</ins><span class="cx"> return isOptionalFormControl(element);
</span><del>- case CSSSelector::PseudoRequired:
</del><ins>+ case CSSSelector::PseudoClassRequired:
</ins><span class="cx"> return isRequiredFormControl(element);
</span><del>- case CSSSelector::PseudoValid:
</del><ins>+ case CSSSelector::PseudoClassValid:
</ins><span class="cx"> return isValid(element);
</span><del>- case CSSSelector::PseudoInvalid:
</del><ins>+ case CSSSelector::PseudoClassInvalid:
</ins><span class="cx"> return isInvalid(element);
</span><del>- case CSSSelector::PseudoChecked:
</del><ins>+ case CSSSelector::PseudoClassChecked:
</ins><span class="cx"> return isChecked(element);
</span><del>- case CSSSelector::PseudoIndeterminate:
</del><ins>+ case CSSSelector::PseudoClassIndeterminate:
</ins><span class="cx"> return shouldAppearIndeterminate(element);
</span><del>- case CSSSelector::PseudoRoot:
</del><ins>+ case CSSSelector::PseudoClassRoot:
</ins><span class="cx"> if (element == element->document().documentElement())
</span><span class="cx"> return true;
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoLang:
</del><ins>+ case CSSSelector::PseudoClassLang:
</ins><span class="cx"> {
</span><span class="cx"> AtomicString value;
</span><span class="cx"> #if ENABLE(VIDEO_TRACK)
</span><span class="lines">@@ -684,35 +684,35 @@
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx"> #if ENABLE(FULLSCREEN_API)
</span><del>- case CSSSelector::PseudoFullScreen:
</del><ins>+ case CSSSelector::PseudoClassFullScreen:
</ins><span class="cx"> return matchesFullScreenPseudoClass(element);
</span><del>- case CSSSelector::PseudoAnimatingFullScreenTransition:
</del><ins>+ case CSSSelector::PseudoClassAnimatingFullScreenTransition:
</ins><span class="cx"> if (element != element->document().webkitCurrentFullScreenElement())
</span><span class="cx"> return false;
</span><span class="cx"> return element->document().isAnimatingFullScreen();
</span><del>- case CSSSelector::PseudoFullScreenAncestor:
</del><ins>+ case CSSSelector::PseudoClassFullScreenAncestor:
</ins><span class="cx"> return element->containsFullScreenElement();
</span><del>- case CSSSelector::PseudoFullScreenDocument:
</del><ins>+ case CSSSelector::PseudoClassFullScreenDocument:
</ins><span class="cx"> // While a Document is in the fullscreen state, the 'full-screen-document' pseudoclass applies
</span><span class="cx"> // to all elements of that Document.
</span><span class="cx"> if (!element->document().webkitIsFullScreen())
</span><span class="cx"> return false;
</span><span class="cx"> return true;
</span><span class="cx"> #endif
</span><del>- case CSSSelector::PseudoInRange:
</del><ins>+ case CSSSelector::PseudoClassInRange:
</ins><span class="cx"> element->document().setContainsValidityStyleRules();
</span><span class="cx"> return element->isInRange();
</span><del>- case CSSSelector::PseudoOutOfRange:
</del><ins>+ case CSSSelector::PseudoClassOutOfRange:
</ins><span class="cx"> element->document().setContainsValidityStyleRules();
</span><span class="cx"> return element->isOutOfRange();
</span><span class="cx"> #if ENABLE(VIDEO_TRACK)
</span><del>- case CSSSelector::PseudoFuture:
</del><ins>+ case CSSSelector::PseudoClassFuture:
</ins><span class="cx"> return matchesFutureCuePseudoClass(element);
</span><del>- case CSSSelector::PseudoPast:
</del><ins>+ case CSSSelector::PseudoClassPast:
</ins><span class="cx"> return matchesPastCuePseudoClass(element);
</span><span class="cx"> #endif
</span><span class="cx">
</span><del>- case CSSSelector::PseudoScope:
</del><ins>+ case CSSSelector::PseudoClassScope:
</ins><span class="cx"> {
</span><span class="cx"> const Node* contextualReferenceNode = !context.scope ? element->document().documentElement() : context.scope;
</span><span class="cx"> if (element == contextualReferenceNode)
</span><span class="lines">@@ -720,19 +720,19 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- case CSSSelector::PseudoHorizontal:
- case CSSSelector::PseudoVertical:
- case CSSSelector::PseudoDecrement:
- case CSSSelector::PseudoIncrement:
- case CSSSelector::PseudoStart:
- case CSSSelector::PseudoEnd:
- case CSSSelector::PseudoDoubleButton:
- case CSSSelector::PseudoSingleButton:
- case CSSSelector::PseudoNoButton:
- case CSSSelector::PseudoCornerPresent:
</del><ins>+ case CSSSelector::PseudoClassHorizontal:
+ case CSSSelector::PseudoClassVertical:
+ case CSSSelector::PseudoClassDecrement:
+ case CSSSelector::PseudoClassIncrement:
+ case CSSSelector::PseudoClassStart:
+ case CSSSelector::PseudoClassEnd:
+ case CSSSelector::PseudoClassDoubleButton:
+ case CSSSelector::PseudoClassSingleButton:
+ case CSSSelector::PseudoClassNoButton:
+ case CSSSelector::PseudoClassCornerPresent:
</ins><span class="cx"> return false;
</span><span class="cx">
</span><del>- case CSSSelector::PseudoUnknown:
</del><ins>+ case CSSSelector::PseudoClassUnknown:
</ins><span class="cx"> default:
</span><span class="cx"> ASSERT_NOT_REACHED();
</span><span class="cx"> break;
</span><span class="lines">@@ -766,18 +766,18 @@
</span><span class="cx">
</span><span class="cx"> // FIXME: This is a temporary hack for resizers and scrollbar corners. Eventually :window-inactive should become a real
</span><span class="cx"> // pseudo class and just apply to everything.
</span><del>- if (selector->pseudoType() == CSSSelector::PseudoWindowInactive)
</del><ins>+ if (selector->pseudoClassType() == CSSSelector::PseudoClassWindowInactive)
</ins><span class="cx"> return !document->page()->focusController().isActive();
</span><span class="cx">
</span><span class="cx"> if (!scrollbar)
</span><span class="cx"> return false;
</span><span class="cx">
</span><del>- switch (selector->pseudoType()) {
- case CSSSelector::PseudoEnabled:
</del><ins>+ switch (selector->pseudoClassType()) {
+ case CSSSelector::PseudoClassEnabled:
</ins><span class="cx"> return scrollbar->enabled();
</span><del>- case CSSSelector::PseudoDisabled:
</del><ins>+ case CSSSelector::PseudoClassDisabled:
</ins><span class="cx"> return !scrollbar->enabled();
</span><del>- case CSSSelector::PseudoHover:
</del><ins>+ case CSSSelector::PseudoClassHover:
</ins><span class="cx"> {
</span><span class="cx"> ScrollbarPart hoveredPart = scrollbar->hoveredPart();
</span><span class="cx"> if (part == ScrollbarBGPart)
</span><span class="lines">@@ -786,7 +786,7 @@
</span><span class="cx"> return hoveredPart == BackTrackPart || hoveredPart == ForwardTrackPart || hoveredPart == ThumbPart;
</span><span class="cx"> return part == hoveredPart;
</span><span class="cx"> }
</span><del>- case CSSSelector::PseudoActive:
</del><ins>+ case CSSSelector::PseudoClassActive:
</ins><span class="cx"> {
</span><span class="cx"> ScrollbarPart pressedPart = scrollbar->pressedPart();
</span><span class="cx"> if (part == ScrollbarBGPart)
</span><span class="lines">@@ -795,19 +795,19 @@
</span><span class="cx"> return pressedPart == BackTrackPart || pressedPart == ForwardTrackPart || pressedPart == ThumbPart;
</span><span class="cx"> return part == pressedPart;
</span><span class="cx"> }
</span><del>- case CSSSelector::PseudoHorizontal:
</del><ins>+ case CSSSelector::PseudoClassHorizontal:
</ins><span class="cx"> return scrollbar->orientation() == HorizontalScrollbar;
</span><del>- case CSSSelector::PseudoVertical:
</del><ins>+ case CSSSelector::PseudoClassVertical:
</ins><span class="cx"> return scrollbar->orientation() == VerticalScrollbar;
</span><del>- case CSSSelector::PseudoDecrement:
</del><ins>+ case CSSSelector::PseudoClassDecrement:
</ins><span class="cx"> return part == BackButtonStartPart || part == BackButtonEndPart || part == BackTrackPart;
</span><del>- case CSSSelector::PseudoIncrement:
</del><ins>+ case CSSSelector::PseudoClassIncrement:
</ins><span class="cx"> return part == ForwardButtonStartPart || part == ForwardButtonEndPart || part == ForwardTrackPart;
</span><del>- case CSSSelector::PseudoStart:
</del><ins>+ case CSSSelector::PseudoClassStart:
</ins><span class="cx"> return part == BackButtonStartPart || part == ForwardButtonStartPart || part == BackTrackPart;
</span><del>- case CSSSelector::PseudoEnd:
</del><ins>+ case CSSSelector::PseudoClassEnd:
</ins><span class="cx"> return part == BackButtonEndPart || part == ForwardButtonEndPart || part == ForwardTrackPart;
</span><del>- case CSSSelector::PseudoDoubleButton:
</del><ins>+ case CSSSelector::PseudoClassDoubleButton:
</ins><span class="cx"> {
</span><span class="cx"> ScrollbarButtonsPlacement buttonsPlacement = scrollbar->theme()->buttonsPlacement();
</span><span class="cx"> if (part == BackButtonStartPart || part == ForwardButtonStartPart || part == BackTrackPart)
</span><span class="lines">@@ -816,14 +816,14 @@
</span><span class="cx"> return buttonsPlacement == ScrollbarButtonsDoubleEnd || buttonsPlacement == ScrollbarButtonsDoubleBoth;
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><del>- case CSSSelector::PseudoSingleButton:
</del><ins>+ case CSSSelector::PseudoClassSingleButton:
</ins><span class="cx"> {
</span><span class="cx"> ScrollbarButtonsPlacement buttonsPlacement = scrollbar->theme()->buttonsPlacement();
</span><span class="cx"> if (part == BackButtonStartPart || part == ForwardButtonEndPart || part == BackTrackPart || part == ForwardTrackPart)
</span><span class="cx"> return buttonsPlacement == ScrollbarButtonsSingle;
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><del>- case CSSSelector::PseudoNoButton:
</del><ins>+ case CSSSelector::PseudoClassNoButton:
</ins><span class="cx"> {
</span><span class="cx"> ScrollbarButtonsPlacement buttonsPlacement = scrollbar->theme()->buttonsPlacement();
</span><span class="cx"> if (part == BackTrackPart)
</span><span class="lines">@@ -832,7 +832,7 @@
</span><span class="cx"> return buttonsPlacement == ScrollbarButtonsNone || buttonsPlacement == ScrollbarButtonsDoubleStart;
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><del>- case CSSSelector::PseudoCornerPresent:
</del><ins>+ case CSSSelector::PseudoClassCornerPresent:
</ins><span class="cx"> return scrollbar->scrollableArea()->isScrollCornerVisible();
</span><span class="cx"> default:
</span><span class="cx"> return false;
</span><span class="lines">@@ -847,8 +847,8 @@
</span><span class="cx"> // :visited never matches other elements than the innermost link element.
</span><span class="cx"> for (; selector; selector = selector->tagHistory()) {
</span><span class="cx"> if (selector->m_match == CSSSelector::PseudoClass) {
</span><del>- switch (selector->pseudoType()) {
- case CSSSelector::PseudoNot:
</del><ins>+ switch (selector->pseudoClassType()) {
+ case CSSSelector::PseudoClassNot:
</ins><span class="cx"> {
</span><span class="cx"> // :not(:visited) is equivalent to :link. Parser enforces that :not can't nest.
</span><span class="cx"> const CSSSelectorList* selectorList = selector->selectorList();
</span><span class="lines">@@ -857,19 +857,19 @@
</span><span class="cx">
</span><span class="cx"> for (const CSSSelector* subSelector = selectorList->first(); subSelector; subSelector = subSelector->tagHistory()) {
</span><span class="cx"> if (subSelector->m_match == CSSSelector::PseudoClass) {
</span><del>- CSSSelector::PseudoType subType = subSelector->pseudoType();
- if (subType == CSSSelector::PseudoVisited)
</del><ins>+ CSSSelector::PseudoClassType subType = subSelector->pseudoClassType();
+ if (subType == CSSSelector::PseudoClassVisited)
</ins><span class="cx"> linkMatchType &= ~SelectorChecker::MatchVisited;
</span><del>- else if (subType == CSSSelector::PseudoLink)
</del><ins>+ else if (subType == CSSSelector::PseudoClassLink)
</ins><span class="cx"> linkMatchType &= ~SelectorChecker::MatchLink;
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoLink:
</del><ins>+ case CSSSelector::PseudoClassLink:
</ins><span class="cx"> linkMatchType &= ~SelectorChecker::MatchVisited;
</span><span class="cx"> break;
</span><del>- case CSSSelector::PseudoVisited:
</del><ins>+ case CSSSelector::PseudoClassVisited:
</ins><span class="cx"> linkMatchType &= ~SelectorChecker::MatchLink;
</span><span class="cx"> break;
</span><span class="cx"> default:
</span><span class="lines">@@ -895,7 +895,7 @@
</span><span class="cx">
</span><span class="cx"> bool SelectorChecker::matchesFocusPseudoClass(const Element* element)
</span><span class="cx"> {
</span><del>- if (InspectorInstrumentation::forcePseudoState(const_cast<Element*>(element), CSSSelector::PseudoFocus))
</del><ins>+ if (InspectorInstrumentation::forcePseudoState(const_cast<Element*>(element), CSSSelector::PseudoClassFocus))
</ins><span class="cx"> return true;
</span><span class="cx"> return element->focused() && isFrameFocused(element);
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorecssSelectorCheckerh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/SelectorChecker.h (167570 => 167571)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/SelectorChecker.h 2014-04-20 19:33:14 UTC (rev 167570)
+++ trunk/Source/WebCore/css/SelectorChecker.h 2014-04-20 20:43:35 UTC (rev 167571)
</span><span class="lines">@@ -108,11 +108,11 @@
</span><span class="cx"> {
</span><span class="cx"> if (selector->m_match != CSSSelector::PseudoClass)
</span><span class="cx"> return false;
</span><del>- CSSSelector::PseudoType pseudoType = selector->pseudoType();
- return pseudoType == CSSSelector::PseudoLink
- || pseudoType == CSSSelector::PseudoAnyLink
- || pseudoType == CSSSelector::PseudoVisited
- || pseudoType == CSSSelector::PseudoFocus;
</del><ins>+ CSSSelector::PseudoClassType pseudoType = selector->pseudoClassType();
+ return pseudoType == CSSSelector::PseudoClassLink
+ || pseudoType == CSSSelector::PseudoClassAnyLink
+ || pseudoType == CSSSelector::PseudoClassVisited
+ || pseudoType == CSSSelector::PseudoClassFocus;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> inline bool SelectorChecker::tagMatches(const Element* element, const QualifiedName& tagQName)
</span></span></pre></div>
<a id="trunkSourceWebCorecssSelectorCheckerFastPathcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/SelectorCheckerFastPath.cpp (167570 => 167571)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/SelectorCheckerFastPath.cpp 2014-04-20 19:33:14 UTC (rev 167570)
+++ trunk/Source/WebCore/css/SelectorCheckerFastPath.cpp 2014-04-20 20:43:35 UTC (rev 167571)
</span><span class="lines">@@ -206,13 +206,13 @@
</span><span class="cx"> bool SelectorCheckerFastPath::commonPseudoClassSelectorMatches(SelectorChecker::VisitedMatchType visitedMatchType) const
</span><span class="cx"> {
</span><span class="cx"> ASSERT(SelectorChecker::isCommonPseudoClassSelector(m_selector));
</span><del>- switch (m_selector->pseudoType()) {
- case CSSSelector::PseudoLink:
- case CSSSelector::PseudoAnyLink:
</del><ins>+ switch (m_selector->pseudoClassType()) {
+ case CSSSelector::PseudoClassLink:
+ case CSSSelector::PseudoClassAnyLink:
</ins><span class="cx"> return m_element->isLink();
</span><del>- case CSSSelector::PseudoVisited:
</del><ins>+ case CSSSelector::PseudoClassVisited:
</ins><span class="cx"> return m_element->isLink() && visitedMatchType == SelectorChecker::VisitedMatchEnabled;
</span><del>- case CSSSelector::PseudoFocus:
</del><ins>+ case CSSSelector::PseudoClassFocus:
</ins><span class="cx"> return SelectorChecker::matchesFocusPseudoClass(m_element);
</span><span class="cx"> default:
</span><span class="cx"> ASSERT_NOT_REACHED();
</span></span></pre></div>
<a id="trunkSourceWebCorecssSelectorPseudoClassAndCompatibilityElementMapin"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/SelectorPseudoClassAndCompatibilityElementMap.in (167570 => 167571)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/SelectorPseudoClassAndCompatibilityElementMap.in 2014-04-20 19:33:14 UTC (rev 167570)
+++ trunk/Source/WebCore/css/SelectorPseudoClassAndCompatibilityElementMap.in 2014-04-20 20:43:35 UTC (rev 167571)
</span><span class="lines">@@ -5,8 +5,8 @@
</span><span class="cx"> -webkit-drag
</span><span class="cx"> -webkit-full-page-media
</span><span class="cx"> active
</span><del>-after, PseudoUnknown, PseudoElementAfter
-before, PseudoUnknown, PseudoElementBefore
</del><ins>+after, PseudoClassUnknown, PseudoElementAfter
+before, PseudoClassUnknown, PseudoElementBefore
</ins><span class="cx"> checked
</span><span class="cx"> corner-present
</span><span class="cx"> decrement
</span><span class="lines">@@ -17,8 +17,8 @@
</span><span class="cx"> enabled
</span><span class="cx"> end
</span><span class="cx"> first-child
</span><del>-first-letter, PseudoUnknown, PseudoElementFirstLetter
-first-line, PseudoUnknown, PseudoElementFirstLine
</del><ins>+first-letter, PseudoClassUnknown, PseudoElementFirstLetter
+first-line, PseudoClassUnknown, PseudoElementFirstLine
</ins><span class="cx"> first-of-type
</span><span class="cx"> focus
</span><span class="cx"> horizontal
</span></span></pre></div>
<a id="trunkSourceWebCorecssSelectorPseudoTypeMaph"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/SelectorPseudoTypeMap.h (167570 => 167571)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/SelectorPseudoTypeMap.h 2014-04-20 19:33:14 UTC (rev 167570)
+++ trunk/Source/WebCore/css/SelectorPseudoTypeMap.h 2014-04-20 20:43:35 UTC (rev 167571)
</span><span class="lines">@@ -32,7 +32,7 @@
</span><span class="cx"> namespace WebCore {
</span><span class="cx">
</span><span class="cx"> struct PseudoClassOrCompatibilityPseudoElement {
</span><del>- CSSSelector::PseudoType pseudoClass;
</del><ins>+ CSSSelector::PseudoClassType pseudoClass;
</ins><span class="cx"> CSSSelector::PseudoElementType compatibilityPseudoElement;
</span><span class="cx"> };
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceWebCorecssStyleResolvercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/StyleResolver.cpp (167570 => 167571)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/StyleResolver.cpp 2014-04-20 19:33:14 UTC (rev 167570)
+++ trunk/Source/WebCore/css/StyleResolver.cpp 2014-04-20 20:43:35 UTC (rev 167571)
</span><span class="lines">@@ -780,7 +780,7 @@
</span><span class="cx"> state.style()->setIsLink(true);
</span><span class="cx"> EInsideLink linkState = state.elementLinkState();
</span><span class="cx"> if (linkState != NotInsideLink) {
</span><del>- bool forceVisited = InspectorInstrumentation::forcePseudoState(element, CSSSelector::PseudoVisited);
</del><ins>+ bool forceVisited = InspectorInstrumentation::forcePseudoState(element, CSSSelector::PseudoClassVisited);
</ins><span class="cx"> if (forceVisited)
</span><span class="cx"> linkState = InsideVisitedLink;
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorecssmakeSelectorPseudoClassAndCompatibilityElementMappy"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/makeSelectorPseudoClassAndCompatibilityElementMap.py (167570 => 167571)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/makeSelectorPseudoClassAndCompatibilityElementMap.py 2014-04-20 19:33:14 UTC (rev 167570)
+++ trunk/Source/WebCore/css/makeSelectorPseudoClassAndCompatibilityElementMap.py 2014-04-20 20:43:35 UTC (rev 167571)
</span><span class="lines">@@ -28,7 +28,7 @@
</span><span class="cx">
</span><span class="cx">
</span><span class="cx"> def enumerablePseudoType(stringPseudoType):
</span><del>- output = ['CSSSelector::Pseudo']
</del><ins>+ output = ['CSSSelector::PseudoClass']
</ins><span class="cx">
</span><span class="cx"> if stringPseudoType.endswith('('):
</span><span class="cx"> stringPseudoType = stringPseudoType[:-1]
</span><span class="lines">@@ -107,7 +107,7 @@
</span><span class="cx">
</span><span class="cx"> %}
</span><span class="cx"> %struct-type
</span><del>-%define initializer-suffix ,{CSSSelector::PseudoUnknown,CSSSelector::PseudoElementUnknown}
</del><ins>+%define initializer-suffix ,{CSSSelector::PseudoClassUnknown,CSSSelector::PseudoElementUnknown}
</ins><span class="cx"> %define class-name SelectorPseudoClassAndCompatibilityElementMapHash
</span><span class="cx"> %omit-struct-type
</span><span class="cx"> %language=C++
</span><span class="lines">@@ -193,7 +193,7 @@
</span><span class="cx">
</span><span class="cx"> if (entry)
</span><span class="cx"> return entry->pseudoTypes;
</span><del>- return { CSSSelector::PseudoUnknown, CSSSelector::PseudoElementUnknown };
</del><ins>+ return { CSSSelector::PseudoClassUnknown, CSSSelector::PseudoElementUnknown };
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> } // namespace WebCore
</span></span></pre></div>
<a id="trunkSourceWebCorecssjitSelectorCompilercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/cssjit/SelectorCompiler.cpp (167570 => 167571)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/cssjit/SelectorCompiler.cpp 2014-04-20 19:33:14 UTC (rev 167570)
+++ trunk/Source/WebCore/cssjit/SelectorCompiler.cpp 2014-04-20 20:43:35 UTC (rev 167571)
</span><span class="lines">@@ -254,82 +254,82 @@
</span><span class="cx"> return std::max(a, b);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static inline FunctionType addPseudoType(const CSSSelector& selector, SelectorFragment& fragment, SelectorContext selectorContext)
</del><ins>+static inline FunctionType addPseudoClassType(const CSSSelector& selector, SelectorFragment& fragment, SelectorContext selectorContext)
</ins><span class="cx"> {
</span><del>- CSSSelector::PseudoType type = selector.pseudoType();
</del><ins>+ CSSSelector::PseudoClassType type = selector.pseudoClassType();
</ins><span class="cx"> switch (type) {
</span><span class="cx"> // Unoptimized pseudo selector. They are just function call to a simple testing function.
</span><del>- case CSSSelector::PseudoAutofill:
</del><ins>+ case CSSSelector::PseudoClassAutofill:
</ins><span class="cx"> fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr(isAutofilled));
</span><span class="cx"> return FunctionType::SimpleSelectorChecker;
</span><del>- case CSSSelector::PseudoChecked:
</del><ins>+ case CSSSelector::PseudoClassChecked:
</ins><span class="cx"> fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr(isChecked));
</span><span class="cx"> return FunctionType::SimpleSelectorChecker;
</span><del>- case CSSSelector::PseudoDefault:
</del><ins>+ case CSSSelector::PseudoClassDefault:
</ins><span class="cx"> fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr(isDefaultButtonForForm));
</span><span class="cx"> return FunctionType::SimpleSelectorChecker;
</span><del>- case CSSSelector::PseudoDisabled:
</del><ins>+ case CSSSelector::PseudoClassDisabled:
</ins><span class="cx"> fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr(isDisabled));
</span><span class="cx"> return FunctionType::SimpleSelectorChecker;
</span><del>- case CSSSelector::PseudoEnabled:
</del><ins>+ case CSSSelector::PseudoClassEnabled:
</ins><span class="cx"> fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr(isEnabled));
</span><span class="cx"> return FunctionType::SimpleSelectorChecker;
</span><del>- case CSSSelector::PseudoFocus:
</del><ins>+ case CSSSelector::PseudoClassFocus:
</ins><span class="cx"> fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr(SelectorChecker::matchesFocusPseudoClass));
</span><span class="cx"> return FunctionType::SimpleSelectorChecker;
</span><del>- case CSSSelector::PseudoIndeterminate:
</del><ins>+ case CSSSelector::PseudoClassIndeterminate:
</ins><span class="cx"> fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr(shouldAppearIndeterminate));
</span><span class="cx"> return FunctionType::SimpleSelectorChecker;
</span><del>- case CSSSelector::PseudoInvalid:
</del><ins>+ case CSSSelector::PseudoClassInvalid:
</ins><span class="cx"> fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr(isInvalid));
</span><span class="cx"> return FunctionType::SimpleSelectorChecker;
</span><del>- case CSSSelector::PseudoOptional:
</del><ins>+ case CSSSelector::PseudoClassOptional:
</ins><span class="cx"> fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr(isOptionalFormControl));
</span><span class="cx"> return FunctionType::SimpleSelectorChecker;
</span><del>- case CSSSelector::PseudoReadOnly:
</del><ins>+ case CSSSelector::PseudoClassReadOnly:
</ins><span class="cx"> fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr(matchesReadOnlyPseudoClass));
</span><span class="cx"> return FunctionType::SimpleSelectorChecker;
</span><del>- case CSSSelector::PseudoReadWrite:
</del><ins>+ case CSSSelector::PseudoClassReadWrite:
</ins><span class="cx"> fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr(matchesReadWritePseudoClass));
</span><span class="cx"> return FunctionType::SimpleSelectorChecker;
</span><del>- case CSSSelector::PseudoRequired:
</del><ins>+ case CSSSelector::PseudoClassRequired:
</ins><span class="cx"> fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr(isRequiredFormControl));
</span><span class="cx"> return FunctionType::SimpleSelectorChecker;
</span><del>- case CSSSelector::PseudoValid:
</del><ins>+ case CSSSelector::PseudoClassValid:
</ins><span class="cx"> fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr(isValid));
</span><span class="cx"> return FunctionType::SimpleSelectorChecker;
</span><span class="cx"> #if ENABLE(FULLSCREEN_API)
</span><del>- case CSSSelector::PseudoFullScreen:
</del><ins>+ case CSSSelector::PseudoClassFullScreen:
</ins><span class="cx"> fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr(matchesFullScreenPseudoClass));
</span><span class="cx"> return FunctionType::SimpleSelectorChecker;
</span><span class="cx"> #endif
</span><span class="cx"> #if ENABLE(VIDEO_TRACK)
</span><del>- case CSSSelector::PseudoFuture:
</del><ins>+ case CSSSelector::PseudoClassFuture:
</ins><span class="cx"> fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr(matchesFutureCuePseudoClass));
</span><span class="cx"> return FunctionType::SimpleSelectorChecker;
</span><del>- case CSSSelector::PseudoPast:
</del><ins>+ case CSSSelector::PseudoClassPast:
</ins><span class="cx"> fragment.unoptimizedPseudoClasses.append(JSC::FunctionPtr(matchesPastCuePseudoClass));
</span><span class="cx"> return FunctionType::SimpleSelectorChecker;
</span><span class="cx"> #endif
</span><span class="cx">
</span><span class="cx"> // Optimized pseudo selectors.
</span><del>- case CSSSelector::PseudoAnyLink:
- fragment.pseudoClasses.add(CSSSelector::PseudoLink);
</del><ins>+ case CSSSelector::PseudoClassAnyLink:
+ fragment.pseudoClasses.add(CSSSelector::PseudoClassLink);
</ins><span class="cx"> return FunctionType::SimpleSelectorChecker;
</span><span class="cx">
</span><del>- case CSSSelector::PseudoLink:
</del><ins>+ case CSSSelector::PseudoClassLink:
</ins><span class="cx"> fragment.pseudoClasses.add(type);
</span><span class="cx"> return FunctionType::SimpleSelectorChecker;
</span><span class="cx">
</span><del>- case CSSSelector::PseudoFirstChild:
- case CSSSelector::PseudoLastChild:
- case CSSSelector::PseudoOnlyChild:
</del><ins>+ case CSSSelector::PseudoClassFirstChild:
+ case CSSSelector::PseudoClassLastChild:
+ case CSSSelector::PseudoClassOnlyChild:
</ins><span class="cx"> fragment.pseudoClasses.add(type);
</span><span class="cx"> if (selectorContext == SelectorContext::QuerySelector)
</span><span class="cx"> return FunctionType::SimpleSelectorChecker;
</span><span class="cx"> return FunctionType::SelectorCheckerWithCheckingContext;
</span><span class="cx">
</span><del>- case CSSSelector::PseudoNthChild:
</del><ins>+ case CSSSelector::PseudoClassNthChild:
</ins><span class="cx"> {
</span><span class="cx"> if (!selector.parseNth())
</span><span class="cx"> return FunctionType::CannotMatchAnything;
</span><span class="lines">@@ -392,7 +392,7 @@
</span><span class="cx"> fragment.classNames.append(selector->value().impl());
</span><span class="cx"> break;
</span><span class="cx"> case CSSSelector::PseudoClass:
</span><del>- m_functionType = mostRestrictiveFunctionType(m_functionType, addPseudoType(*selector, fragment, m_selectorContext));
</del><ins>+ m_functionType = mostRestrictiveFunctionType(m_functionType, addPseudoClassType(*selector, fragment, m_selectorContext));
</ins><span class="cx"> if (m_functionType == FunctionType::CannotCompile || m_functionType == FunctionType::CannotMatchAnything)
</span><span class="cx"> return;
</span><span class="cx"> break;
</span><span class="lines">@@ -1163,7 +1163,7 @@
</span><span class="cx">
</span><span class="cx"> void SelectorCodeGenerator::generateElementMatching(Assembler::JumpList& failureCases, const SelectorFragment& fragment)
</span><span class="cx"> {
</span><del>- if (fragment.pseudoClasses.contains(CSSSelector::PseudoLink))
</del><ins>+ if (fragment.pseudoClasses.contains(CSSSelector::PseudoClassLink))
</ins><span class="cx"> generateElementIsLink(failureCases);
</span><span class="cx">
</span><span class="cx"> if (fragment.tagName)
</span><span class="lines">@@ -1174,11 +1174,11 @@
</span><span class="cx">
</span><span class="cx"> generateElementDataMatching(failureCases, fragment);
</span><span class="cx">
</span><del>- if (fragment.pseudoClasses.contains(CSSSelector::PseudoOnlyChild))
</del><ins>+ if (fragment.pseudoClasses.contains(CSSSelector::PseudoClassOnlyChild))
</ins><span class="cx"> generateElementIsOnlyChild(failureCases, fragment);
</span><del>- if (fragment.pseudoClasses.contains(CSSSelector::PseudoFirstChild))
</del><ins>+ if (fragment.pseudoClasses.contains(CSSSelector::PseudoClassFirstChild))
</ins><span class="cx"> generateElementIsFirstChild(failureCases, fragment);
</span><del>- if (fragment.pseudoClasses.contains(CSSSelector::PseudoLastChild))
</del><ins>+ if (fragment.pseudoClasses.contains(CSSSelector::PseudoClassLastChild))
</ins><span class="cx"> generateElementIsLastChild(failureCases, fragment);
</span><span class="cx"> if (!fragment.nthChildfilters.isEmpty())
</span><span class="cx"> generateElementIsNthChild(failureCases, fragment);
</span></span></pre></div>
<a id="trunkSourceWebCoreinspectorInspectorCSSAgentcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/inspector/InspectorCSSAgent.cpp (167570 => 167571)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/inspector/InspectorCSSAgent.cpp 2014-04-20 19:33:14 UTC (rev 167570)
+++ trunk/Source/WebCore/inspector/InspectorCSSAgent.cpp 2014-04-20 20:43:35 UTC (rev 167571)
</span><span class="lines">@@ -69,11 +69,11 @@
</span><span class="cx"> namespace WebCore {
</span><span class="cx">
</span><span class="cx"> enum ForcePseudoClassFlags {
</span><del>- PseudoNone = 0,
- PseudoHover = 1 << 0,
- PseudoFocus = 1 << 1,
- PseudoActive = 1 << 2,
- PseudoVisited = 1 << 3
</del><ins>+ PseudoClassNone = 0,
+ PseudoClassHover = 1 << 0,
+ PseudoClassFocus = 1 << 1,
+ PseudoClassActive = 1 << 2,
+ PseudoClassVisited = 1 << 3
</ins><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> static unsigned computePseudoClassMask(InspectorArray* pseudoClassArray)
</span><span class="lines">@@ -83,9 +83,9 @@
</span><span class="cx"> DEPRECATED_DEFINE_STATIC_LOCAL(String, focus, (ASCIILiteral("focus")));
</span><span class="cx"> DEPRECATED_DEFINE_STATIC_LOCAL(String, visited, (ASCIILiteral("visited")));
</span><span class="cx"> if (!pseudoClassArray || !pseudoClassArray->length())
</span><del>- return PseudoNone;
</del><ins>+ return PseudoClassNone;
</ins><span class="cx">
</span><del>- unsigned result = PseudoNone;
</del><ins>+ unsigned result = PseudoClassNone;
</ins><span class="cx"> for (size_t i = 0; i < pseudoClassArray->length(); ++i) {
</span><span class="cx"> RefPtr<InspectorValue> pseudoClassValue = pseudoClassArray->get(i);
</span><span class="cx"> String pseudoClass;
</span><span class="lines">@@ -93,13 +93,13 @@
</span><span class="cx"> if (!success)
</span><span class="cx"> continue;
</span><span class="cx"> if (pseudoClass == active)
</span><del>- result |= PseudoActive;
</del><ins>+ result |= PseudoClassActive;
</ins><span class="cx"> else if (pseudoClass == hover)
</span><del>- result |= PseudoHover;
</del><ins>+ result |= PseudoClassHover;
</ins><span class="cx"> else if (pseudoClass == focus)
</span><del>- result |= PseudoFocus;
</del><ins>+ result |= PseudoClassFocus;
</ins><span class="cx"> else if (pseudoClass == visited)
</span><del>- result |= PseudoVisited;
</del><ins>+ result |= PseudoClassVisited;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> return result;
</span><span class="lines">@@ -660,7 +660,7 @@
</span><span class="cx"> m_frontendDispatcher->unregisteredNamedFlowContentElement(documentNodeId, namedFlow->name().string(), contentElementNodeId);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool InspectorCSSAgent::forcePseudoState(Element* element, CSSSelector::PseudoType pseudoType)
</del><ins>+bool InspectorCSSAgent::forcePseudoState(Element* element, CSSSelector::PseudoClassType pseudoClassType)
</ins><span class="cx"> {
</span><span class="cx"> if (m_nodeIdToForcedPseudoState.isEmpty())
</span><span class="cx"> return false;
</span><span class="lines">@@ -674,15 +674,15 @@
</span><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> unsigned forcedPseudoState = it->value;
</span><del>- switch (pseudoType) {
- case CSSSelector::PseudoActive:
- return forcedPseudoState & PseudoActive;
- case CSSSelector::PseudoFocus:
- return forcedPseudoState & PseudoFocus;
- case CSSSelector::PseudoHover:
- return forcedPseudoState & PseudoHover;
- case CSSSelector::PseudoVisited:
- return forcedPseudoState & PseudoVisited;
</del><ins>+ switch (pseudoClassType) {
+ case CSSSelector::PseudoClassActive:
+ return forcedPseudoState & PseudoClassActive;
+ case CSSSelector::PseudoClassFocus:
+ return forcedPseudoState & PseudoClassFocus;
+ case CSSSelector::PseudoClassHover:
+ return forcedPseudoState & PseudoClassHover;
+ case CSSSelector::PseudoClassVisited:
+ return forcedPseudoState & PseudoClassVisited;
</ins><span class="cx"> default:
</span><span class="cx"> return false;
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCoreinspectorInspectorCSSAgenth"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/inspector/InspectorCSSAgent.h (167570 => 167571)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/inspector/InspectorCSSAgent.h 2014-04-20 19:33:14 UTC (rev 167570)
+++ trunk/Source/WebCore/inspector/InspectorCSSAgent.h 2014-04-20 20:43:35 UTC (rev 167571)
</span><span class="lines">@@ -94,7 +94,7 @@
</span><span class="cx">
</span><span class="cx"> static CSSStyleRule* asCSSStyleRule(CSSRule*);
</span><span class="cx">
</span><del>- bool forcePseudoState(Element*, CSSSelector::PseudoType);
</del><ins>+ bool forcePseudoState(Element*, CSSSelector::PseudoClassType);
</ins><span class="cx"> virtual void didCreateFrontendAndBackend(Inspector::InspectorFrontendChannel*, Inspector::InspectorBackendDispatcher*) override;
</span><span class="cx"> virtual void willDestroyFrontendAndBackend(Inspector::InspectorDisconnectReason) override;
</span><span class="cx"> virtual void discardAgent() override;
</span></span></pre></div>
<a id="trunkSourceWebCoreinspectorInspectorInstrumentationcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/inspector/InspectorInstrumentation.cpp (167570 => 167571)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/inspector/InspectorInstrumentation.cpp 2014-04-20 19:33:14 UTC (rev 167570)
+++ trunk/Source/WebCore/inspector/InspectorInstrumentation.cpp 2014-04-20 20:43:35 UTC (rev 167571)
</span><span class="lines">@@ -270,7 +270,7 @@
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool InspectorInstrumentation::forcePseudoStateImpl(InstrumentingAgents* instrumentingAgents, Element* element, CSSSelector::PseudoType pseudoState)
</del><ins>+bool InspectorInstrumentation::forcePseudoStateImpl(InstrumentingAgents* instrumentingAgents, Element* element, CSSSelector::PseudoClassType pseudoState)
</ins><span class="cx"> {
</span><span class="cx"> if (InspectorCSSAgent* cssAgent = instrumentingAgents->inspectorCSSAgent())
</span><span class="cx"> return cssAgent->forcePseudoState(element, pseudoState);
</span></span></pre></div>
<a id="trunkSourceWebCoreinspectorInspectorInstrumentationh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/inspector/InspectorInstrumentation.h (167570 => 167571)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/inspector/InspectorInstrumentation.h 2014-04-20 19:33:14 UTC (rev 167570)
+++ trunk/Source/WebCore/inspector/InspectorInstrumentation.h 2014-04-20 20:43:35 UTC (rev 167571)
</span><span class="lines">@@ -135,7 +135,7 @@
</span><span class="cx"> static void mouseDidMoveOverElement(Page*, const HitTestResult&, unsigned modifierFlags);
</span><span class="cx"> static bool handleMousePress(Page*);
</span><span class="cx"> static bool handleTouchEvent(Page*, Node*);
</span><del>- static bool forcePseudoState(Element*, CSSSelector::PseudoType);
</del><ins>+ static bool forcePseudoState(Element*, CSSSelector::PseudoClassType);
</ins><span class="cx">
</span><span class="cx"> static void willSendXMLHttpRequest(ScriptExecutionContext*, const String& url);
</span><span class="cx"> static void didScheduleResourceRequest(Document*, const String& url);
</span><span class="lines">@@ -334,7 +334,7 @@
</span><span class="cx"> static void mouseDidMoveOverElementImpl(InstrumentingAgents*, const HitTestResult&, unsigned modifierFlags);
</span><span class="cx"> static bool handleTouchEventImpl(InstrumentingAgents*, Node*);
</span><span class="cx"> static bool handleMousePressImpl(InstrumentingAgents*);
</span><del>- static bool forcePseudoStateImpl(InstrumentingAgents*, Element*, CSSSelector::PseudoType);
</del><ins>+ static bool forcePseudoStateImpl(InstrumentingAgents*, Element*, CSSSelector::PseudoClassType);
</ins><span class="cx">
</span><span class="cx"> static void willSendXMLHttpRequestImpl(InstrumentingAgents*, const String& url);
</span><span class="cx"> static void didScheduleResourceRequestImpl(InstrumentingAgents*, const String& url, Frame*);
</span><span class="lines">@@ -779,7 +779,7 @@
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-inline bool InspectorInstrumentation::forcePseudoState(Element* element, CSSSelector::PseudoType pseudoState)
</del><ins>+inline bool InspectorInstrumentation::forcePseudoState(Element* element, CSSSelector::PseudoClassType pseudoState)
</ins><span class="cx"> {
</span><span class="cx"> #if ENABLE(INSPECTOR)
</span><span class="cx"> FAST_RETURN_IF_NO_FRONTENDS(false);
</span></span></pre>
</div>
</div>
</body>
</html>