Corrected serialization of ::cue() functions.

Source/core/css/CSSSelector.cpp

 /*
  * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org)
  *               1999 Waldo Bastian (bastian@kde.org)
  *               2001 Andreas Schlapbach (schlpbch@iam.unibe.ch)
  *               2001-2003 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2002, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2008 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 418 matching lines @@
 void CSSSelector::show() const
 {
     printf("\n******* CSSSelector::show(\"%s\") *******\n", selectorText().ascii().data());
     show(2);
     printf("******* end *******\n");
 }
 #endif
 
 CSSSelector::PseudoType CSSSelector::parsePseudoType(const AtomicString& name, bool hasArguments)
 {
-    CSSSelector::PseudoType pseudoType = nameToPseudoType(name, hasArguments);
+    PseudoType pseudoType = nameToPseudoType(name, hasArguments);
     if (pseudoType != PseudoUnknown)
         return pseudoType;
 
     if (name.startsWith("-webkit-"))
         return PseudoWebKitCustomElement;
 
     return PseudoUnknown;
 }
 
 void CSSSelector::extractPseudoType() const
@@ skipping 135 matching lines @@
     if (sel1 || sel2)
         return false;
 
     return true;
 }
 
 String CSSSelector::selectorText(const String& rightSide) const
 {
     StringBuilder str;
 
-    if (m_match == CSSSelector::Tag && !m_tagIsForNamespaceRule) {
+    if (m_match == Tag && !m_tagIsForNamespaceRule) {
         if (tagQName().prefix().isNull())
             str.append(tagQName().localName());
         else {
             str.append(tagQName().prefix().string());
             str.append('|');
             str.append(tagQName().localName());
         }
     }
 
     const CSSSelector* cs = this;
     while (true) {
-        if (cs->m_match == CSSSelector::Id) {
+        if (cs->m_match == Id) {
             str.append('#');
             serializeIdentifier(cs->value(), str);
-        } else if (cs->m_match == CSSSelector::Class) {
+        } else if (cs->m_match == Class) {
             str.append('.');
             serializeIdentifier(cs->value(), str);
-        } else if (cs->m_match == CSSSelector::PseudoClass || cs->m_match == CSSSelector::PagePseudoClass) {
+        } else if (cs->m_match == PseudoClass || cs->m_match == PagePseudoClass) {
             str.append(':');
             str.append(cs->value());
 
             switch (cs->pseudoType()) {
             case PseudoNot:
                 ASSERT(cs->selectorList());
                 str.append('(');
                 str.append(cs->selectorList()->first()->selectorText());
                 str.append(')');
                 break;
@@ skipping 27 matching lines @@
                             str.append(',');
                         str.append(subSelector->selectorText());
                     }
                     str.append(')');
                 }
                 break;
             }
             default:
                 break;
             }
-        } else if (cs->m_match == CSSSelector::PseudoElement) {
+        } else if (cs->m_match == PseudoElement) {
             str.appendLiteral("::");
             str.append(cs->value());
 
             if (cs->pseudoType() == PseudoContent) {
-                if (cs->relation() == CSSSelector::SubSelector && cs->tagHistory())
+                if (cs->relation() == SubSelector && cs->tagHistory())
                     return cs->tagHistory()->selectorText() + str.toString() + rightSide;
+            } else if (cs->pseudoType() == PseudoCue) {
+                if (cs->selectorList()) {
+                    str.append('(');
+                    const CSSSelector* firstSubSelector = cs->selectorList()->first();
+                    for (const CSSSelector* subSelector = firstSubSelector; subSelector; subSelector = CSSSelectorList::next(*subSelector)) {
+                        if (subSelector != firstSubSelector)
+                            str.append(',');
+                        str.append(subSelector->selectorText());
+                    }
+                    str.append(')');
+                }
             }
         } else if (cs->isAttributeSelector()) {
             str.append('[');
             const AtomicString& prefix = cs->attribute().prefix();
             if (!prefix.isNull()) {
                 str.append(prefix);
                 str.append('|');
             }
             str.append(cs->attribute().localName());
             switch (cs->m_match) {
-            case CSSSelector::AttributeExact:
+            case AttributeExact:
                 str.append('=');
                 break;
-            case CSSSelector::AttributeSet:
+            case AttributeSet:
                 // set has no operator or value, just the attrName
                 str.append(']');
                 break;
-            case CSSSelector::AttributeList:
+            case AttributeList:
                 str.appendLiteral("~=");
                 break;
-            case CSSSelector::AttributeHyphen:
+            case AttributeHyphen:
                 str.appendLiteral("|=");
                 break;
-            case CSSSelector::AttributeBegin:
+            case AttributeBegin:
                 str.appendLiteral("^=");
                 break;
-            case CSSSelector::AttributeEnd:
+            case AttributeEnd:
                 str.appendLiteral("$=");
                 break;
-            case CSSSelector::AttributeContain:
+            case AttributeContain:
                 str.appendLiteral("*=");
                 break;
             default:
                 break;
             }
-            if (cs->m_match != CSSSelector::AttributeSet) {
+            if (cs->m_match != AttributeSet) {
                 serializeString(cs->value(), str);
                 if (cs->attributeMatchType() == CaseInsensitive)
                     str.appendLiteral(" i");
                 str.append(']');
             }
         }
-        if (cs->relation() != CSSSelector::SubSelector || !cs->tagHistory())
+        if (cs->relation() != SubSelector || !cs->tagHistory())
             break;
         cs = cs->tagHistory();
     }
 
     if (const CSSSelector* tagHistory = cs->tagHistory()) {
         switch (cs->relation()) {
-        case CSSSelector::Descendant:
+        case Descendant:
             return tagHistory->selectorText(" " + str.toString() + rightSide);
-        case CSSSelector::Child:
+        case Child:
             return tagHistory->selectorText(" > " + str.toString() + rightSide);
-        case CSSSelector::ShadowDeep:
+        case ShadowDeep:
             return tagHistory->selectorText(" /deep/ " + str.toString() + rightSide);
-        case CSSSelector::DirectAdjacent:
+        case DirectAdjacent:
             return tagHistory->selectorText(" + " + str.toString() + rightSide);
-        case CSSSelector::IndirectAdjacent:
+        case IndirectAdjacent:
             return tagHistory->selectorText(" ~ " + str.toString() + rightSide);
-        case CSSSelector::SubSelector:
+        case SubSelector:
             ASSERT_NOT_REACHED();
-        case CSSSelector::ShadowPseudo:
+        case ShadowPseudo:
             return tagHistory->selectorText(str.toString() + rightSide);
         }
     }
     return str.toString() + rightSide;
 }
 
 void CSSSelector::setAttribute(const QualifiedName& value, AttributeMatchType matchType)
 {
     createRareData();
     m_data.m_rareData->m_attribute = value;
@@ skipping 65 matching lines @@
 
 bool CSSSelector::isCompound() const
 {
     if (!validateSubSelector(this))
         return false;
 
     const CSSSelector* prevSubSelector = this;
     const CSSSelector* subSelector = tagHistory();
 
     while (subSelector) {
-        if (prevSubSelector->relation() != CSSSelector::SubSelector)
+        if (prevSubSelector->relation() != SubSelector)
             return false;
         if (!validateSubSelector(subSelector))
             return false;
 
         prevSubSelector = subSelector;
         subSelector = subSelector->tagHistory();
     }
 
     return true;
 }
@@ skipping 82 matching lines @@
         if (count < nthBValue())
             return false;
         return (count - nthBValue()) % nthAValue() == 0;
     }
     if (count > nthBValue())
         return false;
     return (nthBValue() - count) % (-nthAValue()) == 0;
 }
 
 } // namespace blink