src/third_party/WebKit/Source/core/css/CSSSelector.cpp

   1 /*
   2  * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org)
   3  *               1999 Waldo Bastian (bastian@kde.org)
   4  *               2001 Andreas Schlapbach (schlpbch@iam.unibe.ch)
   5  *               2001-2003 Dirk Mueller (mueller@kde.org)
   6  * Copyright (C) 2002, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
   7  * Copyright (C) 2008 David Smith (catfish.man@gmail.com)
   8  * Copyright (C) 2010 Google Inc. All rights reserved.
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Library General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Library General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Library General Public License
  21  * along with this library; see the file COPYING.LIB.  If not, write to
  22  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  23  * Boston, MA 02110-1301, USA.
  24  */
  25
  26 #include "config.h"
  27 #include "core/css/CSSSelector.h"
  28
  29 #include "core/HTMLNames.h"
  30 #include "core/css/CSSOMUtils.h"
  31 #include "core/css/CSSSelectorList.h"
  32 #include "platform/RuntimeEnabledFeatures.h"
  33 #include "wtf/Assertions.h"
  34 #include "wtf/HashMap.h"
  35 #include "wtf/StdLibExtras.h"
  36 #include "wtf/text/StringBuilder.h"
  37
  38 #ifndef NDEBUG
  39 #include <stdio.h>
  40 #endif
  41
  42 namespace blink {
  43
  44 using namespace HTMLNames;
  45
  46 struct SameSizeAsCSSSelector {
  47     unsigned bitfields;
  48     void *pointers[1];
  49 };
  50
  51 COMPILE_ASSERT(sizeof(CSSSelector) == sizeof(SameSizeAsCSSSelector), CSSSelectorShouldStaySmall);
  52
  53 void CSSSelector::createRareData()
  54 {
  55     ASSERT(m_match != Tag);
  56     if (m_hasRareData)
  57         return;
  58     AtomicString value(m_data.m_value);
  59     if (m_data.m_value)
  60         m_data.m_value->deref();
  61     m_data.m_rareData = RareData::create(value).leakRef();
  62     m_hasRareData = true;
  63 }
  64
  65 unsigned CSSSelector::specificity() const
  66 {
  67     // make sure the result doesn't overflow
  68     static const unsigned maxValueMask = 0xffffff;
  69     static const unsigned idMask = 0xff0000;
  70     static const unsigned classMask = 0xff00;
  71     static const unsigned elementMask = 0xff;
  72
  73     if (isForPage())
  74         return specificityForPage() & maxValueMask;
  75
  76     unsigned total = 0;
  77     unsigned temp = 0;
  78
  79     for (const CSSSelector* selector = this; selector; selector = selector->tagHistory()) {
  80         temp = total + selector->specificityForOneSelector();
  81         // Clamp each component to its max in the case of overflow.
  82         if ((temp & idMask) < (total & idMask))
  83             total |= idMask;
  84         else if ((temp & classMask) < (total & classMask))
  85             total |= classMask;
  86         else if ((temp & elementMask) < (total & elementMask))
  87             total |= elementMask;
  88         else
  89             total = temp;
  90     }
  91     return total;
  92 }
  93
  94 inline unsigned CSSSelector::specificityForOneSelector() const
  95 {
  96     // FIXME: Pseudo-elements and pseudo-classes do not have the same specificity. This function
  97     // isn't quite correct.
  98     switch (m_match) {
  99     case Id:
 100         return 0x10000;
 101     case PseudoClass:
 102         if (pseudoType() == PseudoHost || pseudoType() == PseudoHostContext)
 103             return 0;
 104         // fall through.
 105     case Exact:
 106     case Class:
 107     case Set:
 108     case List:
 109     case Hyphen:
 110     case PseudoElement:
 111     case Contain:
 112     case Begin:
 113     case End:
 114         // FIXME: PseudoAny should base the specificity on the sub-selectors.
 115         // See http://lists.w3.org/Archives/Public/www-style/2010Sep/0530.html
 116         if (pseudoType() == PseudoNot) {
 117             ASSERT(selectorList());
 118             return selectorList()->first()->specificityForOneSelector();
 119         }
 120         return 0x100;
 121     case Tag:
 122         return (tagQName().localName() != starAtom) ? 1 : 0;
 123     case Unknown:
 124         return 0;
 125     }
 126     ASSERT_NOT_REACHED();
 127     return 0;
 128 }
 129
 130 unsigned CSSSelector::specificityForPage() const
 131 {
 132     // See http://dev.w3.org/csswg/css3-page/#cascading-and-page-context
 133     unsigned s = 0;
 134
 135     for (const CSSSelector* component = this; component; component = component->tagHistory()) {
 136         switch (component->m_match) {
 137         case Tag:
 138             s += tagQName().localName() == starAtom ? 0 : 4;
 139             break;
 140         case PagePseudoClass:
 141             switch (component->pseudoType()) {
 142             case PseudoFirstPage:
 143                 s += 2;
 144                 break;
 145             case PseudoLeftPage:
 146             case PseudoRightPage:
 147                 s += 1;
 148                 break;
 149             case PseudoNotParsed:
 150                 break;
 151             default:
 152                 ASSERT_NOT_REACHED();
 153             }
 154             break;
 155         default:
 156             break;
 157         }
 158     }
 159     return s;
 160 }
 161
 162 PseudoId CSSSelector::pseudoId(PseudoType type)
 163 {
 164     switch (type) {
 165     case PseudoFirstLine:
 166         return FIRST_LINE;
 167     case PseudoFirstLetter:
 168         return FIRST_LETTER;
 169     case PseudoSelection:
 170         return SELECTION;
 171     case PseudoBefore:
 172         return BEFORE;
 173     case PseudoAfter:
 174         return AFTER;
 175     case PseudoBackdrop:
 176         return BACKDROP;
 177     case PseudoScrollbar:
 178         return SCROLLBAR;
 179     case PseudoScrollbarButton:
 180         return SCROLLBAR_BUTTON;
 181     case PseudoScrollbarCorner:
 182         return SCROLLBAR_CORNER;
 183     case PseudoScrollbarThumb:
 184         return SCROLLBAR_THUMB;
 185     case PseudoScrollbarTrack:
 186         return SCROLLBAR_TRACK;
 187     case PseudoScrollbarTrackPiece:
 188         return SCROLLBAR_TRACK_PIECE;
 189     case PseudoResizer:
 190         return RESIZER;
 191     case PseudoUnknown:
 192     case PseudoEmpty:
 193     case PseudoFirstChild:
 194     case PseudoFirstOfType:
 195     case PseudoLastChild:
 196     case PseudoLastOfType:
 197     case PseudoOnlyChild:
 198     case PseudoOnlyOfType:
 199     case PseudoNthChild:
 200     case PseudoNthOfType:
 201     case PseudoNthLastChild:
 202     case PseudoNthLastOfType:
 203     case PseudoLink:
 204     case PseudoVisited:
 205     case PseudoAny:
 206     case PseudoAnyLink:
 207     case PseudoAutofill:
 208     case PseudoHover:
 209     case PseudoDrag:
 210     case PseudoFocus:
 211     case PseudoActive:
 212     case PseudoChecked:
 213     case PseudoEnabled:
 214     case PseudoFullPageMedia:
 215     case PseudoDefault:
 216     case PseudoDisabled:
 217     case PseudoOptional:
 218     case PseudoRequired:
 219     case PseudoReadOnly:
 220     case PseudoReadWrite:
 221     case PseudoValid:
 222     case PseudoInvalid:
 223     case PseudoIndeterminate:
 224     case PseudoTarget:
 225     case PseudoLang:
 226     case PseudoNot:
 227     case PseudoRoot:
 228     case PseudoScope:
 229     case PseudoScrollbarBack:
 230     case PseudoScrollbarForward:
 231     case PseudoWindowInactive:
 232     case PseudoCornerPresent:
 233     case PseudoDecrement:
 234     case PseudoIncrement:
 235     case PseudoHorizontal:
 236     case PseudoVertical:
 237     case PseudoStart:
 238     case PseudoEnd:
 239     case PseudoDoubleButton:
 240     case PseudoSingleButton:
 241     case PseudoNoButton:
 242     case PseudoFirstPage:
 243     case PseudoLeftPage:
 244     case PseudoRightPage:
 245     case PseudoInRange:
 246     case PseudoOutOfRange:
 247     case PseudoUserAgentCustomElement:
 248     case PseudoWebKitCustomElement:
 249     case PseudoCue:
 250     case PseudoFutureCue:
 251     case PseudoPastCue:
 252     case PseudoUnresolved:
 253     case PseudoContent:
 254     case PseudoHost:
 255     case PseudoHostContext:
 256     case PseudoShadow:
 257     case PseudoFullScreen:
 258     case PseudoFullScreenDocument:
 259     case PseudoFullScreenAncestor:
 260     case PseudoSpatialNavigationFocus:
 261     case PseudoListBox:
 262         return NOPSEUDO;
 263     case PseudoNotParsed:
 264         ASSERT_NOT_REACHED();
 265         return NOPSEUDO;
 266     }
 267
 268     ASSERT_NOT_REACHED();
 269     return NOPSEUDO;
 270 }
 271
 272 // Could be made smaller and faster by replacing pointer with an
 273 // offset into a string buffer and making the bit fields smaller but
 274 // that could not be maintained by hand.
 275 struct NameToPseudoStruct {
 276     const char* string;
 277     unsigned type:8;
 278 };
 279
 280 // This table should be kept sorted.
 281 const static NameToPseudoStruct pseudoTypeMap[] = {
 282 {"-internal-list-box",            CSSSelector::PseudoListBox},
 283 {"-internal-spatial-navigation-focus", CSSSelector::PseudoSpatialNavigationFocus},
 284 {"-webkit-any(",                  CSSSelector::PseudoAny},
 285 {"-webkit-any-link",              CSSSelector::PseudoAnyLink},
 286 {"-webkit-autofill",              CSSSelector::PseudoAutofill},
 287 {"-webkit-drag",                  CSSSelector::PseudoDrag},
 288 {"-webkit-full-page-media",       CSSSelector::PseudoFullPageMedia},
 289 {"-webkit-full-screen",           CSSSelector::PseudoFullScreen},
 290 {"-webkit-full-screen-ancestor",  CSSSelector::PseudoFullScreenAncestor},
 291 {"-webkit-full-screen-document",  CSSSelector::PseudoFullScreenDocument},
 292 {"-webkit-resizer",               CSSSelector::PseudoResizer},
 293 {"-webkit-scrollbar",             CSSSelector::PseudoScrollbar},
 294 {"-webkit-scrollbar-button",      CSSSelector::PseudoScrollbarButton},
 295 {"-webkit-scrollbar-corner",      CSSSelector::PseudoScrollbarCorner},
 296 {"-webkit-scrollbar-thumb",       CSSSelector::PseudoScrollbarThumb},
 297 {"-webkit-scrollbar-track",       CSSSelector::PseudoScrollbarTrack},
 298 {"-webkit-scrollbar-track-piece", CSSSelector::PseudoScrollbarTrackPiece},
 299 {"active",                        CSSSelector::PseudoActive},
 300 {"after",                         CSSSelector::PseudoAfter},
 301 {"backdrop",                      CSSSelector::PseudoBackdrop},
 302 {"before",                        CSSSelector::PseudoBefore},
 303 {"checked",                       CSSSelector::PseudoChecked},
 304 {"content",                       CSSSelector::PseudoContent},
 305 {"corner-present",                CSSSelector::PseudoCornerPresent},
 306 {"cue",                           CSSSelector::PseudoWebKitCustomElement},
 307 {"cue(",                          CSSSelector::PseudoCue},
 308 {"decrement",                     CSSSelector::PseudoDecrement},
 309 {"default",                       CSSSelector::PseudoDefault},
 310 {"disabled",                      CSSSelector::PseudoDisabled},
 311 {"double-button",                 CSSSelector::PseudoDoubleButton},
 312 {"empty",                         CSSSelector::PseudoEmpty},
 313 {"enabled",                       CSSSelector::PseudoEnabled},
 314 {"end",                           CSSSelector::PseudoEnd},
 315 {"first",                         CSSSelector::PseudoFirstPage},
 316 {"first-child",                   CSSSelector::PseudoFirstChild},
 317 {"first-letter",                  CSSSelector::PseudoFirstLetter},
 318 {"first-line",                    CSSSelector::PseudoFirstLine},
 319 {"first-of-type",                 CSSSelector::PseudoFirstOfType},
 320 {"focus",                         CSSSelector::PseudoFocus},
 321 {"future",                        CSSSelector::PseudoFutureCue},
 322 {"horizontal",                    CSSSelector::PseudoHorizontal},
 323 {"host",                          CSSSelector::PseudoHost},
 324 {"host(",                         CSSSelector::PseudoHost},
 325 {"host-context(",                 CSSSelector::PseudoHostContext},
 326 {"hover",                         CSSSelector::PseudoHover},
 327 {"in-range",                      CSSSelector::PseudoInRange},
 328 {"increment",                     CSSSelector::PseudoIncrement},
 329 {"indeterminate",                 CSSSelector::PseudoIndeterminate},
 330 {"invalid",                       CSSSelector::PseudoInvalid},
 331 {"lang(",                         CSSSelector::PseudoLang},
 332 {"last-child",                    CSSSelector::PseudoLastChild},
 333 {"last-of-type",                  CSSSelector::PseudoLastOfType},
 334 {"left",                          CSSSelector::PseudoLeftPage},
 335 {"link",                          CSSSelector::PseudoLink},
 336 {"no-button",                     CSSSelector::PseudoNoButton},
 337 {"not(",                          CSSSelector::PseudoNot},
 338 {"nth-child(",                    CSSSelector::PseudoNthChild},
 339 {"nth-last-child(",               CSSSelector::PseudoNthLastChild},
 340 {"nth-last-of-type(",             CSSSelector::PseudoNthLastOfType},
 341 {"nth-of-type(",                  CSSSelector::PseudoNthOfType},
 342 {"only-child",                    CSSSelector::PseudoOnlyChild},
 343 {"only-of-type",                  CSSSelector::PseudoOnlyOfType},
 344 {"optional",                      CSSSelector::PseudoOptional},
 345 {"out-of-range",                  CSSSelector::PseudoOutOfRange},
 346 {"past",                          CSSSelector::PseudoPastCue},
 347 {"read-only",                     CSSSelector::PseudoReadOnly},
 348 {"read-write",                    CSSSelector::PseudoReadWrite},
 349 {"required",                      CSSSelector::PseudoRequired},
 350 {"right",                         CSSSelector::PseudoRightPage},
 351 {"root",                          CSSSelector::PseudoRoot},
 352 {"scope",                         CSSSelector::PseudoScope},
 353 {"selection",                     CSSSelector::PseudoSelection},
 354 {"shadow",                        CSSSelector::PseudoShadow},
 355 {"single-button",                 CSSSelector::PseudoSingleButton},
 356 {"start",                         CSSSelector::PseudoStart},
 357 {"target",                        CSSSelector::PseudoTarget},
 358 {"unresolved",                    CSSSelector::PseudoUnresolved},
 359 {"valid",                         CSSSelector::PseudoValid},
 360 {"vertical",                      CSSSelector::PseudoVertical},
 361 {"visited",                       CSSSelector::PseudoVisited},
 362 {"window-inactive",               CSSSelector::PseudoWindowInactive},
 363 };
 364
 365 class NameToPseudoCompare {
 366 public:
 367     NameToPseudoCompare(const AtomicString& key) : m_key(key) { ASSERT(m_key.is8Bit()); }
 368
 369     bool operator()(const NameToPseudoStruct& entry, const NameToPseudoStruct&)
 370     {
 371         ASSERT(entry.string);
 372         const char* key = reinterpret_cast<const char*>(m_key.characters8());
 373         // If strncmp returns 0, then either the keys are equal, or |m_key| sorts before |entry|.
 374         return strncmp(entry.string, key, m_key.length()) < 0;
 375     }
 376
 377 private:
 378     const AtomicString& m_key;
 379 };
 380
 381 static CSSSelector::PseudoType nameToPseudoType(const AtomicString& name)
 382 {
 383     if (name.isNull() || !name.is8Bit())
 384         return CSSSelector::PseudoUnknown;
 385
 386     const NameToPseudoStruct* pseudoTypeMapEnd = pseudoTypeMap + WTF_ARRAY_LENGTH(pseudoTypeMap);
 387     NameToPseudoStruct dummyKey = { 0, CSSSelector::PseudoUnknown };
 388     const NameToPseudoStruct* match = std::lower_bound(pseudoTypeMap, pseudoTypeMapEnd, dummyKey, NameToPseudoCompare(name));
 389     if (match == pseudoTypeMapEnd || match->string != name.string())
 390         return CSSSelector::PseudoUnknown;
 391
 392     return static_cast<CSSSelector::PseudoType>(match->type);
 393 }
 394
 395 #ifndef NDEBUG
 396 void CSSSelector::show(int indent) const
 397 {
 398     printf("%*sselectorText(): %s\n", indent, "", selectorText().ascii().data());
 399     printf("%*sm_match: %d\n", indent, "", m_match);
 400     printf("%*sisCustomPseudoElement(): %d\n", indent, "", isCustomPseudoElement());
 401     if (m_match != Tag)
 402         printf("%*svalue(): %s\n", indent, "", value().ascii().data());
 403     printf("%*spseudoType(): %d\n", indent, "", pseudoType());
 404     if (m_match == Tag)
 405         printf("%*stagQName().localName: %s\n", indent, "", tagQName().localName().ascii().data());
 406     printf("%*sisAttributeSelector(): %d\n", indent, "", isAttributeSelector());
 407     if (isAttributeSelector())
 408         printf("%*sattribute(): %s\n", indent, "", attribute().localName().ascii().data());
 409     printf("%*sargument(): %s\n", indent, "", argument().ascii().data());
 410     printf("%*sspecificity(): %u\n", indent, "", specificity());
 411     if (tagHistory()) {
 412         printf("\n%*s--> (relation == %d)\n", indent, "", relation());
 413         tagHistory()->show(indent + 2);
 414     } else {
 415         printf("\n%*s--> (relation == %d)\n", indent, "", relation());
 416     }
 417 }
 418
 419 void CSSSelector::show() const
 420 {
 421     printf("\n******* CSSSelector::show(\"%s\") *******\n", selectorText().ascii().data());
 422     show(2);
 423     printf("******* end *******\n");
 424 }
 425 #endif
 426
 427 CSSSelector::PseudoType CSSSelector::parsePseudoType(const AtomicString& name)
 428 {
 429     CSSSelector::PseudoType pseudoType = nameToPseudoType(name);
 430     if (pseudoType != PseudoUnknown)
 431         return pseudoType;
 432
 433     if (name.startsWith("-webkit-"))
 434         return PseudoWebKitCustomElement;
 435     if (name.startsWith("cue"))
 436         return PseudoUserAgentCustomElement;
 437
 438     return PseudoUnknown;
 439 }
 440
 441 void CSSSelector::extractPseudoType() const
 442 {
 443     if (m_match != PseudoClass && m_match != PseudoElement && m_match != PagePseudoClass)
 444         return;
 445
 446     m_pseudoType = parsePseudoType(value());
 447
 448     bool element = false; // pseudo-element
 449     bool compat = false; // single colon compatbility mode
 450     bool isPagePseudoClass = false; // Page pseudo-class
 451
 452     switch (m_pseudoType) {
 453     case PseudoAfter:
 454     case PseudoBefore:
 455     case PseudoCue:
 456     case PseudoFirstLetter:
 457     case PseudoFirstLine:
 458         compat = true;
 459     case PseudoBackdrop:
 460     case PseudoResizer:
 461     case PseudoScrollbar:
 462     case PseudoScrollbarCorner:
 463     case PseudoScrollbarButton:
 464     case PseudoScrollbarThumb:
 465     case PseudoScrollbarTrack:
 466     case PseudoScrollbarTrackPiece:
 467     case PseudoSelection:
 468     case PseudoUserAgentCustomElement:
 469     case PseudoWebKitCustomElement:
 470     case PseudoContent:
 471     case PseudoShadow:
 472         element = true;
 473         break;
 474     case PseudoUnknown:
 475     case PseudoEmpty:
 476     case PseudoFirstChild:
 477     case PseudoFirstOfType:
 478     case PseudoLastChild:
 479     case PseudoLastOfType:
 480     case PseudoOnlyChild:
 481     case PseudoOnlyOfType:
 482     case PseudoNthChild:
 483     case PseudoNthOfType:
 484     case PseudoNthLastChild:
 485     case PseudoNthLastOfType:
 486     case PseudoLink:
 487     case PseudoVisited:
 488     case PseudoAny:
 489     case PseudoAnyLink:
 490     case PseudoAutofill:
 491     case PseudoHover:
 492     case PseudoDrag:
 493     case PseudoFocus:
 494     case PseudoActive:
 495     case PseudoChecked:
 496     case PseudoEnabled:
 497     case PseudoFullPageMedia:
 498     case PseudoDefault:
 499     case PseudoDisabled:
 500     case PseudoOptional:
 501     case PseudoRequired:
 502     case PseudoReadOnly:
 503     case PseudoReadWrite:
 504     case PseudoScope:
 505     case PseudoValid:
 506     case PseudoInvalid:
 507     case PseudoIndeterminate:
 508     case PseudoTarget:
 509     case PseudoLang:
 510     case PseudoNot:
 511     case PseudoRoot:
 512     case PseudoScrollbarBack:
 513     case PseudoScrollbarForward:
 514     case PseudoWindowInactive:
 515     case PseudoCornerPresent:
 516     case PseudoDecrement:
 517     case PseudoIncrement:
 518     case PseudoHorizontal:
 519     case PseudoVertical:
 520     case PseudoStart:
 521     case PseudoEnd:
 522     case PseudoDoubleButton:
 523     case PseudoSingleButton:
 524     case PseudoNoButton:
 525     case PseudoNotParsed:
 526     case PseudoFullScreen:
 527     case PseudoFullScreenDocument:
 528     case PseudoFullScreenAncestor:
 529     case PseudoInRange:
 530     case PseudoOutOfRange:
 531     case PseudoFutureCue:
 532     case PseudoPastCue:
 533     case PseudoHost:
 534     case PseudoHostContext:
 535     case PseudoUnresolved:
 536     case PseudoSpatialNavigationFocus:
 537     case PseudoListBox:
 538         break;
 539     case PseudoFirstPage:
 540     case PseudoLeftPage:
 541     case PseudoRightPage:
 542         isPagePseudoClass = true;
 543         break;
 544     }
 545
 546     bool matchPagePseudoClass = (m_match == PagePseudoClass);
 547     if (matchPagePseudoClass != isPagePseudoClass)
 548         m_pseudoType = PseudoUnknown;
 549     else if (m_match == PseudoClass && element) {
 550         if (!compat)
 551             m_pseudoType = PseudoUnknown;
 552         else
 553             m_match = PseudoElement;
 554     } else if (m_match == PseudoElement && !element)
 555         m_pseudoType = PseudoUnknown;
 556 }
 557
 558 bool CSSSelector::operator==(const CSSSelector& other) const
 559 {
 560     const CSSSelector* sel1 = this;
 561     const CSSSelector* sel2 = &other;
 562
 563     while (sel1 && sel2) {
 564         if (sel1->attribute() != sel2->attribute()
 565             || sel1->relation() != sel2->relation()
 566             || sel1->m_match != sel2->m_match
 567             || sel1->value() != sel2->value()
 568             || sel1->pseudoType() != sel2->pseudoType()
 569             || sel1->argument() != sel2->argument()) {
 570             return false;
 571         }
 572         if (sel1->m_match == Tag) {
 573             if (sel1->tagQName() != sel2->tagQName())
 574                 return false;
 575         }
 576         sel1 = sel1->tagHistory();
 577         sel2 = sel2->tagHistory();
 578     }
 579
 580     if (sel1 || sel2)
 581         return false;
 582
 583     return true;
 584 }
 585
 586 String CSSSelector::selectorText(const String& rightSide) const
 587 {
 588     StringBuilder str;
 589
 590     if (m_match == CSSSelector::Tag && !m_tagIsForNamespaceRule) {
 591         if (tagQName().prefix().isNull())
 592             str.append(tagQName().localName());
 593         else {
 594             str.append(tagQName().prefix().string());
 595             str.append('|');
 596             str.append(tagQName().localName());
 597         }
 598     }
 599
 600     const CSSSelector* cs = this;
 601     while (true) {
 602         if (cs->m_match == CSSSelector::Id) {
 603             str.append('#');
 604             serializeIdentifier(cs->value(), str);
 605         } else if (cs->m_match == CSSSelector::Class) {
 606             str.append('.');
 607             serializeIdentifier(cs->value(), str);
 608         } else if (cs->m_match == CSSSelector::PseudoClass || cs->m_match == CSSSelector::PagePseudoClass) {
 609             str.append(':');
 610             str.append(cs->value());
 611
 612             switch (cs->pseudoType()) {
 613             case PseudoNot:
 614                 ASSERT(cs->selectorList());
 615                 str.append(cs->selectorList()->first()->selectorText());
 616                 str.append(')');
 617                 break;
 618             case PseudoLang:
 619             case PseudoNthChild:
 620             case PseudoNthLastChild:
 621             case PseudoNthOfType:
 622             case PseudoNthLastOfType:
 623                 str.append(cs->argument());
 624                 str.append(')');
 625                 break;
 626             case PseudoAny: {
 627                 const CSSSelector* firstSubSelector = cs->selectorList()->first();
 628                 for (const CSSSelector* subSelector = firstSubSelector; subSelector; subSelector = CSSSelectorList::next(*subSelector)) {
 629                     if (subSelector != firstSubSelector)
 630                         str.append(',');
 631                     str.append(subSelector->selectorText());
 632                 }
 633                 str.append(')');
 634                 break;
 635             }
 636             case PseudoHost:
 637             case PseudoHostContext: {
 638                 if (cs->selectorList()) {
 639                     const CSSSelector* firstSubSelector = cs->selectorList()->first();
 640                     for (const CSSSelector* subSelector = firstSubSelector; subSelector; subSelector = CSSSelectorList::next(*subSelector)) {
 641                         if (subSelector != firstSubSelector)
 642                             str.append(',');
 643                         str.append(subSelector->selectorText());
 644                     }
 645                     str.append(')');
 646                 }
 647                 break;
 648             }
 649             default:
 650                 break;
 651             }
 652         } else if (cs->m_match == CSSSelector::PseudoElement) {
 653             str.appendLiteral("::");
 654             str.append(cs->value());
 655
 656             if (cs->pseudoType() == PseudoContent) {
 657                 if (cs->relation() == CSSSelector::SubSelector && cs->tagHistory())
 658                     return cs->tagHistory()->selectorText() + str.toString() + rightSide;
 659             }
 660         } else if (cs->isAttributeSelector()) {
 661             str.append('[');
 662             const AtomicString& prefix = cs->attribute().prefix();
 663             if (!prefix.isNull()) {
 664                 str.append(prefix);
 665                 str.append('|');
 666             }
 667             str.append(cs->attribute().localName());
 668             switch (cs->m_match) {
 669                 case CSSSelector::Exact:
 670                     str.append('=');
 671                     break;
 672                 case CSSSelector::Set:
 673                     // set has no operator or value, just the attrName
 674                     str.append(']');
 675                     break;
 676                 case CSSSelector::List:
 677                     str.appendLiteral("~=");
 678                     break;
 679                 case CSSSelector::Hyphen:
 680                     str.appendLiteral("|=");
 681                     break;
 682                 case CSSSelector::Begin:
 683                     str.appendLiteral("^=");
 684                     break;
 685                 case CSSSelector::End:
 686                     str.appendLiteral("$=");
 687                     break;
 688                 case CSSSelector::Contain:
 689                     str.appendLiteral("*=");
 690                     break;
 691                 default:
 692                     break;
 693             }
 694             if (cs->m_match != CSSSelector::Set) {
 695                 serializeString(cs->value(), str);
 696                 if (cs->attributeMatchType() == CaseInsensitive)
 697                     str.appendLiteral(" i");
 698                 str.append(']');
 699             }
 700         }
 701         if (cs->relation() != CSSSelector::SubSelector || !cs->tagHistory())
 702             break;
 703         cs = cs->tagHistory();
 704     }
 705
 706     if (const CSSSelector* tagHistory = cs->tagHistory()) {
 707         switch (cs->relation()) {
 708         case CSSSelector::Descendant:
 709             return tagHistory->selectorText(" " + str.toString() + rightSide);
 710         case CSSSelector::Child:
 711             return tagHistory->selectorText(" > " + str.toString() + rightSide);
 712         case CSSSelector::ShadowDeep:
 713             return tagHistory->selectorText(" /deep/ " + str.toString() + rightSide);
 714         case CSSSelector::DirectAdjacent:
 715             return tagHistory->selectorText(" + " + str.toString() + rightSide);
 716         case CSSSelector::IndirectAdjacent:
 717             return tagHistory->selectorText(" ~ " + str.toString() + rightSide);
 718         case CSSSelector::SubSelector:
 719             ASSERT_NOT_REACHED();
 720         case CSSSelector::ShadowPseudo:
 721             return tagHistory->selectorText(str.toString() + rightSide);
 722         }
 723     }
 724     return str.toString() + rightSide;
 725 }
 726
 727 void CSSSelector::setAttribute(const QualifiedName& value, AttributeMatchType matchType)
 728 {
 729     createRareData();
 730     m_data.m_rareData->m_attribute = value;
 731     m_data.m_rareData->m_bits.m_attributeMatchType = matchType;
 732 }
 733
 734 void CSSSelector::setArgument(const AtomicString& value)
 735 {
 736     createRareData();
 737     m_data.m_rareData->m_argument = value;
 738 }
 739
 740 void CSSSelector::setSelectorList(PassOwnPtr<CSSSelectorList> selectorList)
 741 {
 742     createRareData();
 743     m_data.m_rareData->m_selectorList = selectorList;
 744 }
 745
 746 static bool validateSubSelector(const CSSSelector* selector)
 747 {
 748     switch (selector->match()) {
 749     case CSSSelector::Tag:
 750     case CSSSelector::Id:
 751     case CSSSelector::Class:
 752     case CSSSelector::Exact:
 753     case CSSSelector::Set:
 754     case CSSSelector::List:
 755     case CSSSelector::Hyphen:
 756     case CSSSelector::Contain:
 757     case CSSSelector::Begin:
 758     case CSSSelector::End:
 759         return true;
 760     case CSSSelector::PseudoElement:
 761     case CSSSelector::Unknown:
 762         return false;
 763     case CSSSelector::PagePseudoClass:
 764     case CSSSelector::PseudoClass:
 765         break;
 766     }
 767
 768     switch (selector->pseudoType()) {
 769     case CSSSelector::PseudoEmpty:
 770     case CSSSelector::PseudoLink:
 771     case CSSSelector::PseudoVisited:
 772     case CSSSelector::PseudoTarget:
 773     case CSSSelector::PseudoEnabled:
 774     case CSSSelector::PseudoDisabled:
 775     case CSSSelector::PseudoChecked:
 776     case CSSSelector::PseudoIndeterminate:
 777     case CSSSelector::PseudoNthChild:
 778     case CSSSelector::PseudoNthLastChild:
 779     case CSSSelector::PseudoNthOfType:
 780     case CSSSelector::PseudoNthLastOfType:
 781     case CSSSelector::PseudoFirstChild:
 782     case CSSSelector::PseudoLastChild:
 783     case CSSSelector::PseudoFirstOfType:
 784     case CSSSelector::PseudoLastOfType:
 785     case CSSSelector::PseudoOnlyOfType:
 786     case CSSSelector::PseudoHost:
 787     case CSSSelector::PseudoHostContext:
 788     case CSSSelector::PseudoNot:
 789     case CSSSelector::PseudoSpatialNavigationFocus:
 790     case CSSSelector::PseudoListBox:
 791         return true;
 792     default:
 793         return false;
 794     }
 795 }
 796
 797 bool CSSSelector::isCompound() const
 798 {
 799     if (!validateSubSelector(this))
 800         return false;
 801
 802     const CSSSelector* prevSubSelector = this;
 803     const CSSSelector* subSelector = tagHistory();
 804
 805     while (subSelector) {
 806         if (prevSubSelector->relation() != CSSSelector::SubSelector)
 807             return false;
 808         if (!validateSubSelector(subSelector))
 809             return false;
 810
 811         prevSubSelector = subSelector;
 812         subSelector = subSelector->tagHistory();
 813     }
 814
 815     return true;
 816 }
 817
 818 bool CSSSelector::parseNth() const
 819 {
 820     if (!m_hasRareData)
 821         return false;
 822     if (m_parsedNth)
 823         return true;
 824     m_parsedNth = m_data.m_rareData->parseNth();
 825     return m_parsedNth;
 826 }
 827
 828 bool CSSSelector::matchNth(int count) const
 829 {
 830     ASSERT(m_hasRareData);
 831     return m_data.m_rareData->matchNth(count);
 832 }
 833
 834 CSSSelector::RareData::RareData(const AtomicString& value)
 835     : m_value(value)
 836     , m_bits()
 837     , m_attribute(anyQName())
 838     , m_argument(nullAtom)
 839 {
 840 }
 841
 842 CSSSelector::RareData::~RareData()
 843 {
 844 }
 845
 846 // a helper function for parsing nth-arguments
 847 bool CSSSelector::RareData::parseNth()
 848 {
 849     String argument = m_argument.lower();
 850
 851     if (argument.isEmpty())
 852         return false;
 853
 854     int nthA = 0;
 855     int nthB = 0;
 856     if (argument == "odd") {
 857         nthA = 2;
 858         nthB = 1;
 859     } else if (argument == "even") {
 860         nthA = 2;
 861         nthB = 0;
 862     } else {
 863         size_t n = argument.find('n');
 864         if (n != kNotFound) {
 865             if (argument[0] == '-') {
 866                 if (n == 1)
 867                     nthA = -1; // -n == -1n
 868                 else
 869                     nthA = argument.substring(0, n).toInt();
 870             } else if (!n) {
 871                 nthA = 1; // n == 1n
 872             } else {
 873                 nthA = argument.substring(0, n).toInt();
 874             }
 875
 876             size_t p = argument.find('+', n);
 877             if (p != kNotFound) {
 878                 nthB = argument.substring(p + 1, argument.length() - p - 1).toInt();
 879             } else {
 880                 p = argument.find('-', n);
 881                 if (p != kNotFound)
 882                     nthB = -argument.substring(p + 1, argument.length() - p - 1).toInt();
 883             }
 884         } else {
 885             nthB = argument.toInt();
 886         }
 887     }
 888     setNthAValue(nthA);
 889     setNthBValue(nthB);
 890     return true;
 891 }
 892
 893 // a helper function for checking nth-arguments
 894 bool CSSSelector::RareData::matchNth(int count)
 895 {
 896     if (!nthAValue())
 897         return count == nthBValue();
 898     if (nthAValue() > 0) {
 899         if (count < nthBValue())
 900             return false;
 901         return (count - nthBValue()) % nthAValue() == 0;
 902     }
 903     if (count > nthBValue())
 904         return false;
 905     return (nthBValue() - count) % (-nthAValue()) == 0;
 906 }
 907
 908 } // namespace blink