Changeset 57809 in webkit


Ignore:
Timestamp:
Apr 19, 2010 6:28:27 AM (14 years ago)
Author:
jberlin@webkit.org
Message:

First steps towards fixing bug 24021 - pseudo-element styles not accessible / retrievable via DOM methods.
​https://bugs.webkit.org/show_bug.cgi?id=24021

Reviewed by Dave Hyatt.

WebCore:

Allows access to the computed styles for the pseudo-elements through the second argument to getComputedStyle.
This approach does not provide the correct values for 'length' properties and does not work for the ':selection' pseudo-element and will instead return results similiar to those returned by Firefox. This approach also requires waiting until at least one iteration of a hardware accelerated composited animation to return the correct values for the "opacity" and "transform" properties of a pseudo-element associated with the element being animated.
Those values need to be retrieved from the renderer for the pseudo-element as opposed to the cached RenderStyle for the element on which the pseudo-element is defined, which is further complicated by the fact that not all elements have renderers.

Test: fast/css/getComputedStyle/getComputedStyle-with-pseudo-element.html

  • WebCore.base.exp:
  • css/CSSComputedStyleDeclaration.cpp:

(WebCore::CSSComputedStyleDeclaration::CSSComputedStyleDeclaration):
Parse the and store the pseudo-element specifier from the string provided by the user.
(WebCore::CSSComputedStyleDeclaration::getFontSizeCSSValuePreferringKeyword):
Get the computed style for the pseudo-element if it has been specified.
(WebCore::CSSComputedStyleDeclaration::getPropertyCSSValue):
Get the computed style for the pseudo-element if it has been specified, with a FIXME noting that the values returned for the "opacity" and "transform" properties of a pseudo-element associated with an element being animated and using hardware accelerated compositing will not be correct until after the first iteration of the animation.
(WebCore::CSSComputedStyleDeclaration::length):
Get the computed style for the pseudo-element if it has been specified.
(WebCore::CSSComputedStyleDeclaration::cssPropertyMatches):
Ditto.

  • css/CSSComputedStyleDeclaration.h:

(WebCore::computedStyle):
Take into consideration the pseudo-element.

  • css/CSSSelector.cpp:

(WebCore::CSSSelector::pseudoId):
Return the PseudoId that corresponds to the given PseudoType. If there is no corresponding PseudoId, returns NOPSEUDO.
(WebCore::nameToPseudoTypeMap):
Create and return the mapping between string names and PseudoTypes.
(WebCore::CSSSelector::parsePseudoType):
Parse and the given string into a PseudoType.
(WebCore::CSSSelector::extractPseudoType):
Refactored to use parsePseudoType.

  • css/CSSSelector.h:
  • css/CSSStyleSelector.cpp:

(WebCore::CSSStyleSelector::SelectorChecker::checkOneSelector):
Refactored to use pseudoId.

  • dom/Element.cpp:

(WebCore::Element::computedStyle):
If the pseudo-element is specified, then return the cached RenderStyle for that PseudoId. Added a FIXME to find the actual renders of the pseudo-elements instead of just the cached RenderStyle of the RenderStyle for the associated element.

  • dom/Element.h:

(WebCore::Element::virtualComputedStyle):
Because Element::computedStyle is used so often, don't make it virtual. Instead, provide a virtualComputedStyle method in the Node.h class andmake computedStyle non-virtual. That way the Element version and the Node version of computedStyle will have the same name and look the same at the call site, but the Element version will be more efficient.

  • dom/Node.h:

(WebCore::Node::computedStyle):
Ditto.

  • dom/Node.cpp:

(WebCore::Node::virtualComputedStyle):
Get the computed style for the pseudo-element if it has been specified.

  • page/DOMWindow.cpp:

(WebCore::DOMWindow::getComputedStyle):
Ditto.

LayoutTests:

  • fast/css/getComputedStyle/getComputedStyle-with-pseudo-element-expected.txt: Added.
  • fast/css/getComputedStyle/getComputedStyle-with-pseudo-element.html: Added.
Location:
trunk
Files:
2 added
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r57808 r57809  
     12010-04-19  Jessie Berlin  <jberlin@webkit.org>
     2
     3        Reviewed by Dave Hyatt.
     4
     5        First steps towards fixing bug 24021 - pseudo-element styles not accessible / retrievable via DOM methods.
     6        https://bugs.webkit.org/show_bug.cgi?id=24021
     7
     8        * fast/css/getComputedStyle/getComputedStyle-with-pseudo-element-expected.txt: Added.
     9        * fast/css/getComputedStyle/getComputedStyle-with-pseudo-element.html: Added.
     10
    1112010-04-19  Csaba Osztrogonác  <ossy@webkit.org>
    212

  • trunk/WebCore/ChangeLog

    r57802 r57809  
     12010-04-19  Jessie Berlin  <jberlin@webkit.org>
     2
     3        Reviewed by Dave Hyatt.
     4
     5        First steps towards fixing bug 24021 - pseudo-element styles not accessible / retrievable via DOM methods.
     6        https://bugs.webkit.org/show_bug.cgi?id=24021
     7
     8        Allows access to the computed styles for the pseudo-elements through the second argument to getComputedStyle.
     9        This approach does not provide the correct values for 'length' properties and does not work for the ':selection' pseudo-element and will instead return results similiar to those returned by Firefox. This approach also requires waiting until at least one iteration of a hardware accelerated composited animation to return the correct values for the "opacity" and "transform" properties of a pseudo-element associated with the element being animated.
     10        Those values need to be retrieved from the renderer for the pseudo-element as opposed to the cached RenderStyle for the element on which the pseudo-element is defined, which is further complicated by the fact that not all elements have renderers.
     11
     12        Test: fast/css/getComputedStyle/getComputedStyle-with-pseudo-element.html
     13
     14        * WebCore.base.exp:
     15        * css/CSSComputedStyleDeclaration.cpp:
     16        (WebCore::CSSComputedStyleDeclaration::CSSComputedStyleDeclaration):
     17        Parse the and store the pseudo-element specifier from the string provided by the user.
     18        (WebCore::CSSComputedStyleDeclaration::getFontSizeCSSValuePreferringKeyword):
     19        Get the computed style for the pseudo-element if it has been specified.
     20        (WebCore::CSSComputedStyleDeclaration::getPropertyCSSValue):
     21        Get the computed style for the pseudo-element if it has been specified, with a FIXME noting that the values returned for the "opacity" and "transform" properties of a pseudo-element associated with an element being animated and using hardware accelerated compositing will not be correct until after the first iteration of the animation.
     22        (WebCore::CSSComputedStyleDeclaration::length):
     23        Get the computed style for the pseudo-element if it has been specified.
     24        (WebCore::CSSComputedStyleDeclaration::cssPropertyMatches):
     25        Ditto.
     26        * css/CSSComputedStyleDeclaration.h:
     27        (WebCore::computedStyle):
     28        Take into consideration the pseudo-element.
     29
     30        * css/CSSSelector.cpp:
     31        (WebCore::CSSSelector::pseudoId):
     32        Return the PseudoId that corresponds to the given PseudoType. If there is no corresponding PseudoId, returns NOPSEUDO.
     33        (WebCore::nameToPseudoTypeMap):
     34        Create and return the mapping between string names and PseudoTypes.
     35        (WebCore::CSSSelector::parsePseudoType):
     36        Parse and the given string into a PseudoType.
     37        (WebCore::CSSSelector::extractPseudoType):
     38        Refactored to use parsePseudoType.
     39        * css/CSSSelector.h:
     40
     41        * css/CSSStyleSelector.cpp:
     42        (WebCore::CSSStyleSelector::SelectorChecker::checkOneSelector):
     43        Refactored to use pseudoId.
     44
     45        * dom/Element.cpp:
     46        (WebCore::Element::computedStyle):
     47        If the pseudo-element is specified, then return the cached RenderStyle for that PseudoId. Added a FIXME to find the actual renders of the pseudo-elements instead of just the cached RenderStyle of the RenderStyle for the associated element.
     48        * dom/Element.h:
     49        (WebCore::Element::virtualComputedStyle):
     50        Because Element::computedStyle is used so often, don't make it virtual. Instead, provide a virtualComputedStyle method in the Node.h class andmake computedStyle non-virtual. That way the Element version and the Node version of computedStyle will have the same name and look the same at the call site, but the Element version will be more efficient.
     51
     52        * dom/Node.h:
     53        (WebCore::Node::computedStyle):
     54        Ditto.
     55        * dom/Node.cpp:
     56        (WebCore::Node::virtualComputedStyle):
     57        Get the computed style for the pseudo-element if it has been specified.
     58
     59        * page/DOMWindow.cpp:
     60        (WebCore::DOMWindow::getComputedStyle):
     61        Ditto.
     62
    1632010-04-18  Simon Hausmann  <simon.hausmann@nokia.com>
    264

  • trunk/WebCore/WebCore.base.exp

    r57748 r57809  
    481481__ZN7WebCore26NetscapePlugInStreamLoader6createEPNS_5FrameEPNS_32NetscapePlugInStreamLoaderClientE
    482482__ZN7WebCore26usesTestModeFocusRingColorEv
    483 __ZN7WebCore27CSSComputedStyleDeclarationC1EN3WTF10PassRefPtrINS_4NodeEEEb
     483__ZN7WebCore27CSSComputedStyleDeclarationC1EN3WTF10PassRefPtrINS_4NodeEEEbRKNS_6StringE
    484484__ZN7WebCore27applicationIsAdobeInstallerEv
    485485__ZN7WebCore29isCharacterSmartReplaceExemptEib

  • trunk/WebCore/css/CSSComputedStyleDeclaration.cpp

    r57482 r57809  
    3232#include "CSSPropertyNames.h"
    3333#include "CSSReflectValue.h"
     34#include "CSSSelector.h"
    3435#include "CSSTimingFunctionValue.h"
    3536#include "CSSValueList.h"
    … …  
    501502}
    502503
    503 CSSComputedStyleDeclaration::CSSComputedStyleDeclaration(PassRefPtr<Node> n, bool allowVisitedStyle)
     504CSSComputedStyleDeclaration::CSSComputedStyleDeclaration(PassRefPtr<Node> n, bool allowVisitedStyle, const String& pseudoElementName)
    504505    : m_node(n)
    505506    , m_allowVisitedStyle(allowVisitedStyle)
    506507{
     508    unsigned nameWithoutColonsStart = pseudoElementName[0] == ':' ? (pseudoElementName[1] == ':' ? 2 : 1) : 0;
     509    m_pseudoElementSpecifier = CSSSelector::pseudoId(CSSSelector::parsePseudoType(
     510        AtomicString(pseudoElementName.substring(nameWithoutColonsStart))));
    507511}
    508512
    … …  
    547551    node->document()->updateLayoutIgnorePendingStylesheets();
    548552
    549     RefPtr<RenderStyle> style = node->computedStyle();
     553    RefPtr<RenderStyle> style = node->computedStyle(m_pseudoElementSpecifier);
    550554    if (!style)
    551555        return 0;
    … …  
    665669
    666670    RefPtr<RenderStyle> style;
    667     if (renderer && hasCompositedLayer(renderer) && AnimationController::supportsAcceleratedAnimationOfProperty(static_cast<CSSPropertyID>(propertyID)))
     671    if (renderer && hasCompositedLayer(renderer) && AnimationController::supportsAcceleratedAnimationOfProperty(static_cast<CSSPropertyID>(propertyID))) {
    668672        style = renderer->animation()->getAnimatedStyleForRenderer(renderer);
    669     else
    670        style = node->computedStyle();
     673        if (m_pseudoElementSpecifier) {
     674            // FIXME: This cached pseudo style will only exist if the animation has been run at least once.
     675            style = style->getCachedPseudoStyle(m_pseudoElementSpecifier);
     676        }
     677    } else
     678        style = node->computedStyle(m_pseudoElementSpecifier);
     679
    671680    if (!style)
    672681        return 0;
    … …  
    14971506        return 0;
    14981507
    1499     RenderStyle* style = node->computedStyle();
     1508    RenderStyle* style = node->computedStyle(m_pseudoElementSpecifier);
    15001509    if (!style)
    15011510        return 0;
    … …  
    15161525    if (property->id() == CSSPropertyFontSize && property->value()->isPrimitiveValue() && m_node) {
    15171526        m_node->document()->updateLayoutIgnorePendingStylesheets();
    1518         RenderStyle* style = m_node->computedStyle();
     1527        RenderStyle* style = m_node->computedStyle(m_pseudoElementSpecifier);
    15191528        if (style && style->fontDescription().keywordSize()) {
    15201529            int sizeValue = cssIdentifierForFontSizeKeyword(style->fontDescription().keywordSize());

  • trunk/WebCore/css/CSSComputedStyleDeclaration.h

    r57292 r57809  
    2424#include "CSSStyleDeclaration.h"
    2525#include "Node.h"
     26#include "RenderStyleConstants.h"
    2627
    2728namespace WebCore {
    … …  
    3435class CSSComputedStyleDeclaration : public CSSStyleDeclaration {
    3536public:
    36     friend PassRefPtr<CSSComputedStyleDeclaration> computedStyle(PassRefPtr<Node>, bool allowVisitedStyle = false);
     37    friend PassRefPtr<CSSComputedStyleDeclaration> computedStyle(PassRefPtr<Node>, bool allowVisitedStyle, const String& pseudoElementName);
    3738    virtual ~CSSComputedStyleDeclaration();
    3839
    … …  
    6162
    6263private:
    63     CSSComputedStyleDeclaration(PassRefPtr<Node>, bool allowVisitedStyle);
     64    CSSComputedStyleDeclaration(PassRefPtr<Node>, bool allowVisitedStyle, const String&);
    6465
    6566    virtual void setCssText(const String&, ExceptionCode&);
    … …  
    7172
    7273    RefPtr<Node> m_node;
     74    PseudoId m_pseudoElementSpecifier;
    7375    bool m_allowVisitedStyle;
    7476};
    7577
    76 inline PassRefPtr<CSSComputedStyleDeclaration> computedStyle(PassRefPtr<Node> node, bool allowVisitedStyle)
     78inline PassRefPtr<CSSComputedStyleDeclaration> computedStyle(PassRefPtr<Node> node,  bool allowVisitedStyle = false, const String& pseudoElementName = String())
    7779{
    78     return adoptRef(new CSSComputedStyleDeclaration(node, allowVisitedStyle));
     80    return adoptRef(new CSSComputedStyleDeclaration(node, allowVisitedStyle, pseudoElementName));
    7981}
    8082

  • trunk/WebCore/css/CSSSelector.cpp

    r57161 r57809  
    2929#include "HTMLNames.h"
    3030
     31#include <wtf/HashMap.h>
    3132#include <wtf/StdLibExtras.h>
    3233
    … …  
    6667}
    6768
    68 void CSSSelector::extractPseudoType() const
    69 {
    70     if (m_match != PseudoClass && m_match != PseudoElement)
    71         return;
    72 
     69PseudoId CSSSelector::pseudoId(PseudoType type)
     70{
     71    switch (type) {
     72    case PseudoFirstLine:
     73        return FIRST_LINE;
     74    case PseudoFirstLetter:
     75        return FIRST_LETTER;
     76    case PseudoSelection:
     77        return SELECTION;
     78    case PseudoBefore:
     79        return BEFORE;
     80    case PseudoAfter:
     81        return AFTER;
     82    case PseudoFileUploadButton:
     83        return FILE_UPLOAD_BUTTON;
     84#if ENABLE(DATALIST)
     85    case PseudoInputListButton:
     86        return INPUT_LIST_BUTTON;
     87#endif
     88    case PseudoInputPlaceholder:
     89        return INPUT_PLACEHOLDER;
     90    case PseudoSliderThumb:
     91        return SLIDER_THUMB;
     92    case PseudoSearchCancelButton:
     93        return SEARCH_CANCEL_BUTTON;
     94    case PseudoSearchDecoration:
     95        return SEARCH_DECORATION;
     96    case PseudoSearchResultsDecoration:
     97        return SEARCH_RESULTS_DECORATION;
     98    case PseudoSearchResultsButton:
     99        return SEARCH_RESULTS_BUTTON;
     100    case PseudoMediaControlsPanel:
     101        return MEDIA_CONTROLS_PANEL;
     102    case PseudoMediaControlsMuteButton:
     103        return MEDIA_CONTROLS_MUTE_BUTTON;
     104    case PseudoMediaControlsPlayButton:
     105        return MEDIA_CONTROLS_PLAY_BUTTON;
     106    case PseudoMediaControlsTimelineContainer:
     107        return MEDIA_CONTROLS_TIMELINE_CONTAINER;
     108    case PseudoMediaControlsVolumeSliderContainer:
     109        return MEDIA_CONTROLS_VOLUME_SLIDER_CONTAINER;
     110    case PseudoMediaControlsCurrentTimeDisplay:
     111        return MEDIA_CONTROLS_CURRENT_TIME_DISPLAY;
     112    case PseudoMediaControlsTimeRemainingDisplay:
     113        return MEDIA_CONTROLS_TIME_REMAINING_DISPLAY;
     114    case PseudoMediaControlsTimeline:
     115        return MEDIA_CONTROLS_TIMELINE;
     116    case PseudoMediaControlsVolumeSlider:
     117        return MEDIA_CONTROLS_VOLUME_SLIDER;
     118    case PseudoMediaControlsSeekBackButton:
     119        return MEDIA_CONTROLS_SEEK_BACK_BUTTON;
     120    case PseudoMediaControlsSeekForwardButton:
     121        return MEDIA_CONTROLS_SEEK_FORWARD_BUTTON;
     122    case PseudoMediaControlsRewindButton:
     123        return MEDIA_CONTROLS_REWIND_BUTTON;
     124    case PseudoMediaControlsReturnToRealtimeButton:
     125        return MEDIA_CONTROLS_RETURN_TO_REALTIME_BUTTON;
     126    case PseudoMediaControlsToggleClosedCaptions:
     127        return MEDIA_CONTROLS_TOGGLE_CLOSED_CAPTIONS_BUTTON;
     128    case PseudoMediaControlsStatusDisplay:
     129        return MEDIA_CONTROLS_STATUS_DISPLAY;
     130    case PseudoMediaControlsFullscreenButton:
     131        return MEDIA_CONTROLS_FULLSCREEN_BUTTON;
     132    case PseudoScrollbar:
     133        return SCROLLBAR;
     134    case PseudoScrollbarButton:
     135        return SCROLLBAR_BUTTON;
     136    case PseudoScrollbarCorner:
     137        return SCROLLBAR_CORNER;
     138    case PseudoScrollbarThumb:
     139        return SCROLLBAR_THUMB;
     140    case PseudoScrollbarTrack:
     141        return SCROLLBAR_TRACK;
     142    case PseudoScrollbarTrackPiece:
     143        return SCROLLBAR_TRACK_PIECE;
     144    case PseudoResizer:
     145        return RESIZER;
     146    case PseudoInnerSpinButton:
     147        return INNER_SPIN_BUTTON;
     148    case PseudoOuterSpinButton:
     149        return OUTER_SPIN_BUTTON;
     150    case PseudoUnknown:
     151    case PseudoEmpty:
     152    case PseudoFirstChild:
     153    case PseudoFirstOfType:
     154    case PseudoLastChild:
     155    case PseudoLastOfType:
     156    case PseudoOnlyChild:
     157    case PseudoOnlyOfType:
     158    case PseudoNthChild:
     159    case PseudoNthOfType:
     160    case PseudoNthLastChild:
     161    case PseudoNthLastOfType:
     162    case PseudoLink:
     163    case PseudoVisited:
     164    case PseudoAnyLink:
     165    case PseudoAutofill:
     166    case PseudoHover:
     167    case PseudoDrag:
     168    case PseudoFocus:
     169    case PseudoActive:
     170    case PseudoChecked:
     171    case PseudoEnabled:
     172    case PseudoFullPageMedia:
     173    case PseudoDefault:
     174    case PseudoDisabled:
     175    case PseudoOptional:
     176    case PseudoRequired:
     177    case PseudoReadOnly:
     178    case PseudoReadWrite:
     179    case PseudoValid:
     180    case PseudoInvalid:
     181    case PseudoIndeterminate:
     182    case PseudoTarget:
     183    case PseudoLang:
     184    case PseudoNot:
     185    case PseudoRoot:
     186    case PseudoScrollbarBack:
     187    case PseudoScrollbarForward:
     188    case PseudoWindowInactive:
     189    case PseudoCornerPresent:
     190    case PseudoDecrement:
     191    case PseudoIncrement:
     192    case PseudoHorizontal:
     193    case PseudoVertical:
     194    case PseudoStart:
     195    case PseudoEnd:
     196    case PseudoDoubleButton:
     197    case PseudoSingleButton:
     198    case PseudoNoButton:
     199        return NOPSEUDO;
     200    case PseudoNotParsed:
     201        ASSERT_NOT_REACHED();
     202        return NOPSEUDO;
     203    }
     204
     205    ASSERT_NOT_REACHED();
     206    return NOPSEUDO;
     207}
     208
     209static HashMap<AtomicStringImpl*, CSSSelector::PseudoType>* nameToPseudoTypeMap()
     210{
    73211    DEFINE_STATIC_LOCAL(AtomicString, active, ("active"));
    74212    DEFINE_STATIC_LOCAL(AtomicString, after, ("after"));
    … …  
    162300    DEFINE_STATIC_LOCAL(AtomicString, cornerPresent, ("corner-present"));
    163301
     302    static HashMap<AtomicStringImpl*, CSSSelector::PseudoType>* nameToPseudoType = 0;
     303    if (!nameToPseudoType) {
     304        nameToPseudoType = new HashMap<AtomicStringImpl*, CSSSelector::PseudoType>;
     305        nameToPseudoType->set(active.impl(), CSSSelector::PseudoActive);
     306        nameToPseudoType->set(after.impl(), CSSSelector::PseudoAfter);
     307        nameToPseudoType->set(anyLink.impl(), CSSSelector::PseudoAnyLink);
     308        nameToPseudoType->set(autofill.impl(), CSSSelector::PseudoAutofill);
     309        nameToPseudoType->set(before.impl(), CSSSelector::PseudoBefore);
     310        nameToPseudoType->set(checked.impl(), CSSSelector::PseudoChecked);
     311        nameToPseudoType->set(fileUploadButton.impl(), CSSSelector::PseudoFileUploadButton);
     312        nameToPseudoType->set(defaultString.impl(), CSSSelector::PseudoDefault);
     313        nameToPseudoType->set(disabled.impl(), CSSSelector::PseudoDisabled);
     314        nameToPseudoType->set(readOnly.impl(), CSSSelector::PseudoReadOnly);
     315        nameToPseudoType->set(readWrite.impl(), CSSSelector::PseudoReadWrite);
     316        nameToPseudoType->set(valid.impl(), CSSSelector::PseudoValid);
     317        nameToPseudoType->set(invalid.impl(), CSSSelector::PseudoInvalid);
     318        nameToPseudoType->set(drag.impl(), CSSSelector::PseudoDrag);
     319        nameToPseudoType->set(dragAlias.impl(), CSSSelector::PseudoDrag);
     320        nameToPseudoType->set(enabled.impl(), CSSSelector::PseudoEnabled);
     321        nameToPseudoType->set(empty.impl(), CSSSelector::PseudoEmpty);
     322        nameToPseudoType->set(firstChild.impl(), CSSSelector::PseudoFirstChild);
     323        nameToPseudoType->set(fullPageMedia.impl(), CSSSelector::PseudoFullPageMedia);
     324#if ENABLE(DATALIST)
     325        nameToPseudoType->set(inputListButton.impl(), CSSSelector::PseudoInputListButton);
     326#endif
     327        nameToPseudoType->set(inputPlaceholder.impl(), CSSSelector::PseudoInputPlaceholder);
     328        nameToPseudoType->set(lastChild.impl(), CSSSelector::PseudoLastChild);
     329        nameToPseudoType->set(lastOfType.impl(), CSSSelector::PseudoLastOfType);
     330        nameToPseudoType->set(onlyChild.impl(), CSSSelector::PseudoOnlyChild);
     331        nameToPseudoType->set(onlyOfType.impl(), CSSSelector::PseudoOnlyOfType);
     332        nameToPseudoType->set(firstLetter.impl(), CSSSelector::PseudoFirstLetter);
     333        nameToPseudoType->set(firstLine.impl(), CSSSelector::PseudoFirstLine);
     334        nameToPseudoType->set(firstOfType.impl(), CSSSelector::PseudoFirstOfType);
     335        nameToPseudoType->set(focus.impl(), CSSSelector::PseudoFocus);
     336        nameToPseudoType->set(hover.impl(), CSSSelector::PseudoHover);
     337        nameToPseudoType->set(indeterminate.impl(), CSSSelector::PseudoIndeterminate);
     338        nameToPseudoType->set(innerSpinButton.impl(), CSSSelector::PseudoInnerSpinButton);
     339        nameToPseudoType->set(link.impl(), CSSSelector::PseudoLink);
     340        nameToPseudoType->set(lang.impl(), CSSSelector::PseudoLang);
     341        nameToPseudoType->set(mediaControlsPanel.impl(), CSSSelector::PseudoMediaControlsPanel);
     342        nameToPseudoType->set(mediaControlsMuteButton.impl(), CSSSelector::PseudoMediaControlsMuteButton);
     343        nameToPseudoType->set(mediaControlsPlayButton.impl(), CSSSelector::PseudoMediaControlsPlayButton);
     344        nameToPseudoType->set(mediaControlsCurrentTimeDisplay.impl(), CSSSelector::PseudoMediaControlsCurrentTimeDisplay);
     345        nameToPseudoType->set(mediaControlsTimeRemainingDisplay.impl(), CSSSelector::PseudoMediaControlsTimeRemainingDisplay);
     346        nameToPseudoType->set(mediaControlsTimeline.impl(), CSSSelector::PseudoMediaControlsTimeline);
     347        nameToPseudoType->set(mediaControlsVolumeSlider.impl(), CSSSelector::PseudoMediaControlsVolumeSlider);
     348        nameToPseudoType->set(mediaControlsSeekBackButton.impl(), CSSSelector::PseudoMediaControlsSeekBackButton);
     349        nameToPseudoType->set(mediaControlsSeekForwardButton.impl(), CSSSelector::PseudoMediaControlsSeekForwardButton);
     350        nameToPseudoType->set(mediaControlsRewindButton.impl(), CSSSelector::PseudoMediaControlsRewindButton);
     351        nameToPseudoType->set(mediaControlsReturnToRealtimeButton.impl(), CSSSelector::PseudoMediaControlsReturnToRealtimeButton);
     352        nameToPseudoType->set(mediaControlsToggleClosedCaptionsButton.impl(), CSSSelector::PseudoMediaControlsToggleClosedCaptions);
     353        nameToPseudoType->set(mediaControlsStatusDisplay.impl(), CSSSelector::PseudoMediaControlsStatusDisplay);
     354        nameToPseudoType->set(mediaControlsFullscreenButton.impl(), CSSSelector::PseudoMediaControlsFullscreenButton);
     355        nameToPseudoType->set(mediaControlsTimelineContainer.impl(), CSSSelector::PseudoMediaControlsTimelineContainer);
     356        nameToPseudoType->set(mediaControlsVolumeSliderContainer.impl(), CSSSelector::PseudoMediaControlsVolumeSliderContainer);
     357        nameToPseudoType->set(notStr.impl(), CSSSelector::PseudoNot);
     358        nameToPseudoType->set(nthChild.impl(), CSSSelector::PseudoNthChild);
     359        nameToPseudoType->set(nthOfType.impl(), CSSSelector::PseudoNthOfType);
     360        nameToPseudoType->set(nthLastChild.impl(), CSSSelector::PseudoNthLastChild);
     361        nameToPseudoType->set(nthLastOfType.impl(), CSSSelector::PseudoNthLastOfType);
     362        nameToPseudoType->set(outerSpinButton.impl(), CSSSelector::PseudoOuterSpinButton);
     363        nameToPseudoType->set(root.impl(), CSSSelector::PseudoRoot);
     364        nameToPseudoType->set(windowInactive.impl(), CSSSelector::PseudoWindowInactive);
     365        nameToPseudoType->set(decrement.impl(), CSSSelector::PseudoDecrement);
     366        nameToPseudoType->set(increment.impl(), CSSSelector::PseudoIncrement);
     367        nameToPseudoType->set(start.impl(), CSSSelector::PseudoStart);
     368        nameToPseudoType->set(end.impl(), CSSSelector::PseudoEnd);
     369        nameToPseudoType->set(horizontal.impl(), CSSSelector::PseudoHorizontal);
     370        nameToPseudoType->set(vertical.impl(), CSSSelector::PseudoVertical);
     371        nameToPseudoType->set(doubleButton.impl(), CSSSelector::PseudoDoubleButton);
     372        nameToPseudoType->set(singleButton.impl(), CSSSelector::PseudoSingleButton);
     373        nameToPseudoType->set(noButton.impl(), CSSSelector::PseudoNoButton);
     374        nameToPseudoType->set(optional.impl(), CSSSelector::PseudoOptional);
     375        nameToPseudoType->set(required.impl(), CSSSelector::PseudoRequired);
     376        nameToPseudoType->set(resizer.impl(), CSSSelector::PseudoResizer);
     377        nameToPseudoType->set(scrollbar.impl(), CSSSelector::PseudoScrollbar);
     378        nameToPseudoType->set(scrollbarButton.impl(), CSSSelector::PseudoScrollbarButton);
     379        nameToPseudoType->set(scrollbarCorner.impl(), CSSSelector::PseudoScrollbarCorner);
     380        nameToPseudoType->set(scrollbarThumb.impl(), CSSSelector::PseudoScrollbarThumb);
     381        nameToPseudoType->set(scrollbarTrack.impl(), CSSSelector::PseudoScrollbarTrack);
     382        nameToPseudoType->set(scrollbarTrackPiece.impl(), CSSSelector::PseudoScrollbarTrackPiece);
     383        nameToPseudoType->set(cornerPresent.impl(), CSSSelector::PseudoCornerPresent);
     384        nameToPseudoType->set(searchCancelButton.impl(), CSSSelector::PseudoSearchCancelButton);
     385        nameToPseudoType->set(searchDecoration.impl(), CSSSelector::PseudoSearchDecoration);
     386        nameToPseudoType->set(searchResultsDecoration.impl(), CSSSelector::PseudoSearchResultsDecoration);
     387        nameToPseudoType->set(searchResultsButton.impl(), CSSSelector::PseudoSearchResultsButton);
     388        nameToPseudoType->set(selection.impl(), CSSSelector::PseudoSelection);
     389        nameToPseudoType->set(sliderThumb.impl(), CSSSelector::PseudoSliderThumb);
     390        nameToPseudoType->set(target.impl(), CSSSelector::PseudoTarget);
     391        nameToPseudoType->set(visited.impl(), CSSSelector::PseudoVisited);
     392    }
     393    return nameToPseudoType;
     394}
     395
     396CSSSelector::PseudoType CSSSelector::parsePseudoType(const AtomicString& name)
     397{
     398    if (name.isNull())
     399        return PseudoUnknown;
     400    HashMap<AtomicStringImpl*, CSSSelector::PseudoType>* nameToPseudoType = nameToPseudoTypeMap();
     401    HashMap<AtomicStringImpl*, CSSSelector::PseudoType>::iterator slot = nameToPseudoType->find(name.impl());
     402    return slot == nameToPseudoType->end() ? PseudoUnknown : slot->second;
     403}
     404
     405void CSSSelector::extractPseudoType() const
     406{
     407    if (m_match != PseudoClass && m_match != PseudoElement)
     408        return;
     409
     410    m_pseudoType = parsePseudoType(m_value);
     411
    164412    bool element = false; // pseudo-element
    165413    bool compat = false; // single colon compatbility mode
    166414
    167     m_pseudoType = PseudoUnknown;
    168     if (m_value == active)
    169         m_pseudoType = PseudoActive;
    170     else if (m_value == after) {
    171         m_pseudoType = PseudoAfter;
     415    switch (m_pseudoType) {
     416    case PseudoAfter:
     417    case PseudoBefore:
     418    case PseudoFirstLetter:
     419    case PseudoFirstLine:
     420        compat = true;
     421    case PseudoFileUploadButton:
     422    case PseudoInputListButton:
     423    case PseudoInputPlaceholder:
     424    case PseudoInnerSpinButton:
     425    case PseudoMediaControlsPanel:
     426    case PseudoMediaControlsMuteButton:
     427    case PseudoMediaControlsPlayButton:
     428    case PseudoMediaControlsCurrentTimeDisplay:
     429    case PseudoMediaControlsTimeRemainingDisplay:
     430    case PseudoMediaControlsTimeline:
     431    case PseudoMediaControlsVolumeSlider:
     432    case PseudoMediaControlsSeekBackButton:
     433    case PseudoMediaControlsSeekForwardButton:
     434    case PseudoMediaControlsRewindButton:
     435    case PseudoMediaControlsReturnToRealtimeButton:
     436    case PseudoMediaControlsToggleClosedCaptions:
     437    case PseudoMediaControlsStatusDisplay:
     438    case PseudoMediaControlsFullscreenButton:
     439    case PseudoMediaControlsTimelineContainer:
     440    case PseudoMediaControlsVolumeSliderContainer:
     441    case PseudoOuterSpinButton:
     442    case PseudoResizer:
     443    case PseudoScrollbar:
     444    case PseudoScrollbarCorner:
     445    case PseudoScrollbarButton:
     446    case PseudoScrollbarThumb:
     447    case PseudoScrollbarTrack:
     448    case PseudoScrollbarTrackPiece:
     449    case PseudoSearchCancelButton:
     450    case PseudoSearchDecoration:
     451    case PseudoSearchResultsDecoration:
     452    case PseudoSearchResultsButton:
     453    case PseudoSelection:
     454    case PseudoSliderThumb:
    172455        element = true;
    173         compat = true;
    174     } else if (m_value == anyLink)
    175         m_pseudoType = PseudoAnyLink;
    176     else if (m_value == autofill)
    177         m_pseudoType = PseudoAutofill;
    178     else if (m_value == before) {
    179         m_pseudoType = PseudoBefore;
    180         element = true;
    181         compat = true;
    182     } else if (m_value == checked)
    183         m_pseudoType = PseudoChecked;
    184     else if (m_value == fileUploadButton) {
    185         m_pseudoType = PseudoFileUploadButton;
    186         element = true;
    187     } else if (m_value == defaultString)
    188         m_pseudoType = PseudoDefault;
    189     else if (m_value == disabled)
    190         m_pseudoType = PseudoDisabled;
    191     else if (m_value == readOnly)
    192         m_pseudoType = PseudoReadOnly;
    193     else if (m_value == readWrite)
    194         m_pseudoType = PseudoReadWrite;
    195     else if (m_value == valid)
    196         m_pseudoType = PseudoValid;
    197     else if (m_value == invalid)
    198         m_pseudoType = PseudoInvalid;
    199     else if (m_value == drag || m_value == dragAlias)
    200         m_pseudoType = PseudoDrag;
    201     else if (m_value == enabled)
    202         m_pseudoType = PseudoEnabled;
    203     else if (m_value == empty)
    204         m_pseudoType = PseudoEmpty;
    205     else if (m_value == firstChild)
    206         m_pseudoType = PseudoFirstChild;
    207     else if (m_value == fullPageMedia)
    208         m_pseudoType = PseudoFullPageMedia;
    209     else
    210 #if ENABLE(DATALIST)
    211     if (m_value == inputListButton) {
    212         m_pseudoType = PseudoInputListButton;
    213         element = true;
    214     } else
    215 #endif
    216     if (m_value == inputPlaceholder) {
    217         m_pseudoType = PseudoInputPlaceholder;
    218         element = true;
    219     } else if (m_value == lastChild)
    220         m_pseudoType = PseudoLastChild;
    221     else if (m_value == lastOfType)
    222         m_pseudoType = PseudoLastOfType;
    223     else if (m_value == onlyChild)
    224         m_pseudoType = PseudoOnlyChild;
    225     else if (m_value == onlyOfType)
    226         m_pseudoType = PseudoOnlyOfType;
    227     else if (m_value == firstLetter) {
    228         m_pseudoType = PseudoFirstLetter;
    229         element = true;
    230         compat = true;
    231     } else if (m_value == firstLine) {
    232         m_pseudoType = PseudoFirstLine;
    233         element = true;
    234         compat = true;
    235     } else if (m_value == firstOfType)
    236         m_pseudoType = PseudoFirstOfType;
    237     else if (m_value == focus)
    238         m_pseudoType = PseudoFocus;
    239     else if (m_value == hover)
    240         m_pseudoType = PseudoHover;
    241     else if (m_value == indeterminate)
    242         m_pseudoType = PseudoIndeterminate;
    243     else if (m_value == innerSpinButton) {
    244         m_pseudoType = PseudoInnerSpinButton;
    245         element = true;
    246     } else if (m_value == link)
    247         m_pseudoType = PseudoLink;
    248     else if (m_value == lang)
    249         m_pseudoType = PseudoLang;
    250     else if (m_value == mediaControlsPanel) {
    251         m_pseudoType = PseudoMediaControlsPanel;
    252         element = true;
    253     } else if (m_value == mediaControlsMuteButton) {
    254         m_pseudoType = PseudoMediaControlsMuteButton;
    255         element = true;
    256     } else if (m_value == mediaControlsPlayButton) {
    257         m_pseudoType = PseudoMediaControlsPlayButton;
    258         element = true;
    259     } else if (m_value == mediaControlsCurrentTimeDisplay) {
    260         m_pseudoType = PseudoMediaControlsCurrentTimeDisplay;
    261         element = true;
    262     } else if (m_value == mediaControlsTimeRemainingDisplay) {
    263         m_pseudoType = PseudoMediaControlsTimeRemainingDisplay;
    264         element = true;
    265     } else if (m_value == mediaControlsTimeline) {
    266         m_pseudoType = PseudoMediaControlsTimeline;
    267         element = true;
    268     } else if (m_value == mediaControlsVolumeSlider) {
    269         m_pseudoType = PseudoMediaControlsVolumeSlider;
    270         element = true;
    271     } else if (m_value == mediaControlsSeekBackButton) {
    272         m_pseudoType = PseudoMediaControlsSeekBackButton;
    273         element = true;
    274     } else if (m_value == mediaControlsSeekForwardButton) {
    275         m_pseudoType = PseudoMediaControlsSeekForwardButton;
    276         element = true;
    277     } else if (m_value == mediaControlsRewindButton) {
    278         m_pseudoType = PseudoMediaControlsRewindButton;
    279         element = true;
    280     } else if (m_value == mediaControlsReturnToRealtimeButton) {
    281         m_pseudoType = PseudoMediaControlsReturnToRealtimeButton;
    282         element = true;
    283     } else if (m_value == mediaControlsToggleClosedCaptionsButton) {
    284         m_pseudoType = PseudoMediaControlsToggleClosedCaptions;
    285         element = true;
    286     } else if (m_value == mediaControlsStatusDisplay) {
    287         m_pseudoType = PseudoMediaControlsStatusDisplay;
    288         element = true;
    289     } else if (m_value == mediaControlsFullscreenButton) {
    290         m_pseudoType = PseudoMediaControlsFullscreenButton;
    291         element = true;
    292     } else if (m_value == mediaControlsTimelineContainer) {
    293         m_pseudoType = PseudoMediaControlsTimelineContainer;
    294         element = true;
    295     } else if (m_value == mediaControlsVolumeSliderContainer) {
    296         m_pseudoType = PseudoMediaControlsVolumeSliderContainer;
    297         element = true;
    298     } else if (m_value == notStr)
    299         m_pseudoType = PseudoNot;
    300     else if (m_value == nthChild)
    301         m_pseudoType = PseudoNthChild;
    302     else if (m_value == nthOfType)
    303         m_pseudoType = PseudoNthOfType;
    304     else if (m_value == nthLastChild)
    305         m_pseudoType = PseudoNthLastChild;
    306     else if (m_value == nthLastOfType)
    307         m_pseudoType = PseudoNthLastOfType;
    308     else if (m_value == outerSpinButton) {
    309         m_pseudoType = PseudoOuterSpinButton;
    310         element = true;
    311     } else if (m_value == root)
    312         m_pseudoType = PseudoRoot;
    313     else if (m_value == windowInactive)
    314         m_pseudoType = PseudoWindowInactive;
    315     else if (m_value == decrement)
    316         m_pseudoType = PseudoDecrement;
    317     else if (m_value == increment)
    318         m_pseudoType = PseudoIncrement;
    319     else if (m_value == start)
    320         m_pseudoType = PseudoStart;
    321     else if (m_value == end)
    322         m_pseudoType = PseudoEnd;
    323     else if (m_value == horizontal)
    324         m_pseudoType = PseudoHorizontal;
    325     else if (m_value == vertical)
    326         m_pseudoType = PseudoVertical;
    327     else if (m_value == doubleButton)
    328         m_pseudoType = PseudoDoubleButton;
    329     else if (m_value == singleButton)
    330         m_pseudoType = PseudoSingleButton;
    331     else if (m_value == noButton)
    332         m_pseudoType = PseudoNoButton;
    333     else if (m_value == optional)
    334         m_pseudoType = PseudoOptional;
    335     else if (m_value == required)
    336         m_pseudoType = PseudoRequired;
    337     else if (m_value == scrollbarCorner) {
    338         element = true;
    339         m_pseudoType = PseudoScrollbarCorner;
    340     } else if (m_value == resizer) {
    341         element = true;
    342         m_pseudoType = PseudoResizer;
    343     } else if (m_value == scrollbar) {
    344         element = true;
    345         m_pseudoType = PseudoScrollbar;
    346     } else if (m_value == scrollbarButton) {
    347         element = true;
    348         m_pseudoType = PseudoScrollbarButton;
    349     } else if (m_value == scrollbarCorner) {
    350         element = true;
    351         m_pseudoType = PseudoScrollbarCorner;
    352     } else if (m_value == scrollbarThumb) {
    353         element = true;
    354         m_pseudoType = PseudoScrollbarThumb;
    355     } else if (m_value == scrollbarTrack) {
    356         element = true;
    357         m_pseudoType = PseudoScrollbarTrack;
    358     } else if (m_value == scrollbarTrackPiece) {
    359         element = true;
    360         m_pseudoType = PseudoScrollbarTrackPiece;
    361     } else if (m_value == cornerPresent)
    362          m_pseudoType = PseudoCornerPresent;
    363     else if (m_value == searchCancelButton) {
    364         m_pseudoType = PseudoSearchCancelButton;
    365         element = true;
    366     } else if (m_value == searchDecoration) {
    367         m_pseudoType = PseudoSearchDecoration;
    368         element = true;
    369     } else if (m_value == searchResultsDecoration) {
    370         m_pseudoType = PseudoSearchResultsDecoration;
    371         element = true;
    372     } else if (m_value == searchResultsButton) {
    373         m_pseudoType = PseudoSearchResultsButton;
    374         element = true;
    375     }  else if (m_value == selection) {
    376         m_pseudoType = PseudoSelection;
    377         element = true;
    378     } else if (m_value == sliderThumb) {
    379         m_pseudoType = PseudoSliderThumb;
    380         element = true;
    381     } else if (m_value == target)
    382         m_pseudoType = PseudoTarget;
    383     else if (m_value == visited)
    384         m_pseudoType = PseudoVisited;
     456        break;
     457    case PseudoUnknown:
     458    case PseudoEmpty:
     459    case PseudoFirstChild:
     460    case PseudoFirstOfType:
     461    case PseudoLastChild:
     462    case PseudoLastOfType:
     463    case PseudoOnlyChild:
     464    case PseudoOnlyOfType:
     465    case PseudoNthChild:
     466    case PseudoNthOfType:
     467    case PseudoNthLastChild:
     468    case PseudoNthLastOfType:
     469    case PseudoLink:
     470    case PseudoVisited:
     471    case PseudoAnyLink:
     472    case PseudoAutofill:
     473    case PseudoHover:
     474    case PseudoDrag:
     475    case PseudoFocus:
     476    case PseudoActive:
     477    case PseudoChecked:
     478    case PseudoEnabled:
     479    case PseudoFullPageMedia:
     480    case PseudoDefault:
     481    case PseudoDisabled:
     482    case PseudoOptional:
     483    case PseudoRequired:
     484    case PseudoReadOnly:
     485    case PseudoReadWrite:
     486    case PseudoValid:
     487    case PseudoInvalid:
     488    case PseudoIndeterminate:
     489    case PseudoTarget:
     490    case PseudoLang:
     491    case PseudoNot:
     492    case PseudoRoot:
     493    case PseudoScrollbarBack:
     494    case PseudoScrollbarForward:
     495    case PseudoWindowInactive:
     496    case PseudoCornerPresent:
     497    case PseudoDecrement:
     498    case PseudoIncrement:
     499    case PseudoHorizontal:
     500    case PseudoVertical:
     501    case PseudoStart:
     502    case PseudoEnd:
     503    case PseudoDoubleButton:
     504    case PseudoSingleButton:
     505    case PseudoNoButton:
     506    case PseudoNotParsed:
     507        break;
     508    }
    385509
    386510    if (m_match == PseudoClass && element) {
    387         if (!compat) 
     511        if (!compat)
    388512            m_pseudoType = PseudoUnknown;
    389         else 
     513        else
    390514           m_match = PseudoElement;
    391515    } else if (m_match == PseudoElement && !element)

  • trunk/WebCore/css/CSSSelector.h

    r57161 r57809  
    2323#define CSSSelector_h
    2424
     25#include "RenderStyleConstants.h"
    2526#include "QualifiedName.h"
    2627#include <wtf/Noncopyable.h>
    … …  
    195196            return static_cast<PseudoType>(m_pseudoType);
    196197        }
    197        
     198
     199        static PseudoType parsePseudoType(const AtomicString&);
     200        static PseudoId pseudoId(PseudoType);
     201
    198202        CSSSelector* tagHistory() const { return m_hasRareData ? m_data.m_rareData->m_tagHistory.get() : m_data.m_tagHistory; }
    199203        void setTagHistory(CSSSelector* tagHistory);

  • trunk/WebCore/css/CSSStyleSelector.cpp

    r57671 r57809  
    25532553            return false;
    25542554
    2555         switch (sel->pseudoType()) {
    2556             // Pseudo-elements:
    2557             case CSSSelector::PseudoFirstLine:
    2558                 dynamicPseudo = FIRST_LINE;
    2559                 return true;
    2560             case CSSSelector::PseudoFirstLetter:
    2561                 dynamicPseudo = FIRST_LETTER;
    2562                 if (Document* doc = e->document())
    2563                     doc->setUsesFirstLetterRules(true);
    2564                 return true;
    2565             case CSSSelector::PseudoSelection:
    2566                 dynamicPseudo = SELECTION;
    2567                 return true;
    2568             case CSSSelector::PseudoBefore:
    2569                 dynamicPseudo = BEFORE;
    2570                 return true;
    2571             case CSSSelector::PseudoAfter:
    2572                 dynamicPseudo = AFTER;
    2573                 return true;
    2574             case CSSSelector::PseudoFileUploadButton:
    2575                 dynamicPseudo = FILE_UPLOAD_BUTTON;
    2576                 return true;
    2577 #if ENABLE(DATALIST)
    2578             case CSSSelector::PseudoInputListButton:
    2579                 dynamicPseudo = INPUT_LIST_BUTTON;
    2580                 return true;
    2581 #endif
    2582             case CSSSelector::PseudoInputPlaceholder:
    2583                 dynamicPseudo = INPUT_PLACEHOLDER;
    2584                 return true;
    2585             case CSSSelector::PseudoSliderThumb:
    2586                 dynamicPseudo = SLIDER_THUMB;
    2587                 return true;
    2588             case CSSSelector::PseudoSearchCancelButton:
    2589                 dynamicPseudo = SEARCH_CANCEL_BUTTON;
    2590                 return true;
    2591             case CSSSelector::PseudoSearchDecoration:
    2592                 dynamicPseudo = SEARCH_DECORATION;
    2593                 return true;
    2594             case CSSSelector::PseudoSearchResultsDecoration:
    2595                 dynamicPseudo = SEARCH_RESULTS_DECORATION;
    2596                 return true;
    2597             case CSSSelector::PseudoSearchResultsButton:
    2598                 dynamicPseudo = SEARCH_RESULTS_BUTTON;
    2599                 return true;
    2600             case CSSSelector::PseudoMediaControlsPanel:
    2601                 dynamicPseudo = MEDIA_CONTROLS_PANEL;
    2602                 return true;
    2603             case CSSSelector::PseudoMediaControlsMuteButton:
    2604                 dynamicPseudo = MEDIA_CONTROLS_MUTE_BUTTON;
    2605                 return true;
    2606             case CSSSelector::PseudoMediaControlsPlayButton:
    2607                 dynamicPseudo = MEDIA_CONTROLS_PLAY_BUTTON;
    2608                 return true;
    2609             case CSSSelector::PseudoMediaControlsTimelineContainer:
    2610                 dynamicPseudo = MEDIA_CONTROLS_TIMELINE_CONTAINER;
    2611                 return true;
    2612             case CSSSelector::PseudoMediaControlsVolumeSliderContainer:
    2613                 dynamicPseudo = MEDIA_CONTROLS_VOLUME_SLIDER_CONTAINER;
    2614                 return true;
    2615             case CSSSelector::PseudoMediaControlsCurrentTimeDisplay:
    2616                 dynamicPseudo = MEDIA_CONTROLS_CURRENT_TIME_DISPLAY;
    2617                 return true;
    2618             case CSSSelector::PseudoMediaControlsTimeRemainingDisplay:
    2619                 dynamicPseudo = MEDIA_CONTROLS_TIME_REMAINING_DISPLAY;
    2620                 return true;
    2621             case CSSSelector::PseudoMediaControlsTimeline:
    2622                 dynamicPseudo = MEDIA_CONTROLS_TIMELINE;
    2623                 return true;
    2624             case CSSSelector::PseudoMediaControlsVolumeSlider:
    2625                 dynamicPseudo = MEDIA_CONTROLS_VOLUME_SLIDER;
    2626                 return true;
    2627             case CSSSelector::PseudoMediaControlsSeekBackButton:
    2628                 dynamicPseudo = MEDIA_CONTROLS_SEEK_BACK_BUTTON;
    2629                 return true;
    2630             case CSSSelector::PseudoMediaControlsSeekForwardButton:
    2631                 dynamicPseudo = MEDIA_CONTROLS_SEEK_FORWARD_BUTTON;
    2632                 return true;
    2633             case CSSSelector::PseudoMediaControlsRewindButton:
    2634                 dynamicPseudo = MEDIA_CONTROLS_REWIND_BUTTON;
    2635                 return true;
    2636             case CSSSelector::PseudoMediaControlsReturnToRealtimeButton:
    2637                 dynamicPseudo = MEDIA_CONTROLS_RETURN_TO_REALTIME_BUTTON;
    2638                 return true;
    2639             case CSSSelector::PseudoMediaControlsToggleClosedCaptions:
    2640                 dynamicPseudo = MEDIA_CONTROLS_TOGGLE_CLOSED_CAPTIONS_BUTTON;
    2641                 return true;
    2642             case CSSSelector::PseudoMediaControlsStatusDisplay:
    2643                 dynamicPseudo = MEDIA_CONTROLS_STATUS_DISPLAY;
    2644                 return true;
    2645             case CSSSelector::PseudoMediaControlsFullscreenButton:
    2646                 dynamicPseudo = MEDIA_CONTROLS_FULLSCREEN_BUTTON;
    2647                 return true;
    2648             case CSSSelector::PseudoScrollbar:
    2649                 dynamicPseudo = SCROLLBAR;
    2650                 return true;
    2651             case CSSSelector::PseudoScrollbarButton:
    2652                 dynamicPseudo = SCROLLBAR_BUTTON;
    2653                 return true;
    2654             case CSSSelector::PseudoScrollbarCorner:
    2655                 dynamicPseudo = SCROLLBAR_CORNER;
    2656                 return true;
    2657             case CSSSelector::PseudoScrollbarThumb:
    2658                 dynamicPseudo = SCROLLBAR_THUMB;
    2659                 return true;
    2660             case CSSSelector::PseudoScrollbarTrack:
    2661                 dynamicPseudo = SCROLLBAR_TRACK;
    2662                 return true;
    2663             case CSSSelector::PseudoScrollbarTrackPiece:
    2664                 dynamicPseudo = SCROLLBAR_TRACK_PIECE;
    2665                 return true;
    2666             case CSSSelector::PseudoResizer:
    2667                 dynamicPseudo = RESIZER;
    2668                 return true;
    2669             case CSSSelector::PseudoInnerSpinButton:
    2670                 dynamicPseudo = INNER_SPIN_BUTTON;
    2671                 return true;
    2672             case CSSSelector::PseudoOuterSpinButton:
    2673                 dynamicPseudo = OUTER_SPIN_BUTTON;
    2674                 return true;
    2675             case CSSSelector::PseudoUnknown:
    2676             case CSSSelector::PseudoNotParsed:
    2677             default:
    2678                 ASSERT_NOT_REACHED();
    2679                 break;
    2680         }
     2555        PseudoId pseudoId = CSSSelector::pseudoId(sel->pseudoType());
     2556        if (pseudoId == FIRST_LETTER) {
     2557            if (Document* document = e->document())
     2558                document->setUsesFirstLetterRules(true);
     2559        }
     2560        if (pseudoId != NOPSEUDO) {
     2561            dynamicPseudo = pseudoId;
     2562            return true;
     2563        }
     2564        ASSERT_NOT_REACHED();
    26812565        return false;
    26822566    }

  • trunk/WebCore/dom/Element.cpp

    r57671 r57809  
    13991399}
    14001400
    1401 RenderStyle* Element::computedStyle()
    1402 {
     1401RenderStyle* Element::computedStyle(PseudoId pseudoElementSpecifier)
     1402{
     1403    // FIXME: Find and use the renderer from the pseudo element instead of the actual element so that the 'length'
     1404    // properties, which are only known by the renderer because it did the layout, will be correct and so that the
     1405    // values returned for the ":selection" pseudo-element will be correct.
    14031406    if (RenderStyle* usedStyle = renderStyle())
    1404         return usedStyle;
     1407        return pseudoElementSpecifier ? usedStyle->getCachedPseudoStyle(pseudoElementSpecifier) : usedStyle;
    14051408
    14061409    if (!attached())
    … …  
    14121415    if (!data->m_computedStyle)
    14131416        data->m_computedStyle = document()->styleForElementIgnoringPendingStylesheets(this);
    1414     return data->m_computedStyle.get();
     1417    return pseudoElementSpecifier ? data->m_computedStyle->getCachedPseudoStyle(pseudoElementSpecifier) : data->m_computedStyle.get();
    14151418}
    14161419

  • trunk/WebCore/dom/Element.h

    r57012 r57809  
    202202    virtual void recalcStyle(StyleChange = NoChange);
    203203
    204     virtual RenderStyle* computedStyle();
     204    RenderStyle* computedStyle(PseudoId = NOPSEUDO);
    205205
    206206    void dispatchAttrRemovalEvent(Attribute*);
    … …  
    313313    virtual const AtomicString& virtualLocalName() const { return localName(); }
    314314    virtual const AtomicString& virtualNamespaceURI() const { return namespaceURI(); }
     315    virtual RenderStyle* virtualComputedStyle(PseudoId pseudoElementSpecifier = NOPSEUDO) { return computedStyle(pseudoElementSpecifier); }
    315316   
    316317    // cloneNode is private so that non-virtual cloneElementWithChildren and cloneElementWithoutChildren

  • trunk/WebCore/dom/Node.cpp

    r57116 r57809  
    14331433}
    14341434
    1435 RenderStyle* Node::computedStyle()
    1436 {
    1437     return parent() ? parent()->computedStyle() : 0;
     1435RenderStyle* Node::virtualComputedStyle(PseudoId pseudoElementSpecifier)
     1436{
     1437    return parent() ? parent()->computedStyle(pseudoElementSpecifier) : 0;
    14381438}
    14391439

  • trunk/WebCore/dom/Node.h

    r56152 r57809  
    2828#include "EventTarget.h"
    2929#include "KURLHash.h"
     30#include "RenderStyleConstants.h"
    3031#include "ScriptWrappable.h"
    3132#include "TreeShared.h"
    … …  
    446447    virtual void setRenderStyle(PassRefPtr<RenderStyle>);
    447448
    448     virtual RenderStyle* computedStyle();
     449    RenderStyle* computedStyle(PseudoId pseudoElementSpecifier = NOPSEUDO) { return virtualComputedStyle(pseudoElementSpecifier); }
    449450
    450451    // -----------------------------------------------------------------------------
    … …  
    600601    virtual const AtomicString& virtualLocalName() const;
    601602    virtual const AtomicString& virtualNamespaceURI() const;
     603    virtual RenderStyle* virtualComputedStyle(PseudoId = NOPSEUDO);
    602604
    603605    Element* ancestorElement() const;

  • trunk/WebCore/page/DOMWindow.cpp

    r57077 r57809  
    11441144}
    11451145
    1146 PassRefPtr<CSSStyleDeclaration> DOMWindow::getComputedStyle(Element* elt, const String&) const
     1146PassRefPtr<CSSStyleDeclaration> DOMWindow::getComputedStyle(Element* elt, const String& pseudoElt) const
    11471147{
    11481148    if (!elt)
    11491149        return 0;
    11501150
    1151     // FIXME: This needs take pseudo elements into account.
    1152     return computedStyle(elt);
     1151    return computedStyle(elt, false, pseudoElt);
    11531152}
    11541153
Note: See TracChangeset for help on using the changeset viewer.