ChangeLog

2015-03-05  sylvain-galineau  <galineau@adobe.com>

        Need support for :dir() pseudo-class

        https://bugs.webkit.org/show_bug.cgi?id=64861

        Reviewed by NOBODY (OOPS!).

        No new tests (OOPS!).

        * css/CSSSelector.cpp:

        (WebCore::CSSSelector::parseDirection): for :dir argument

        * css/CSSSelector.h:

        * css/SelectorChecker.cpp:

        (WebCore::SelectorChecker::checkOne): matching

        * dom/Element.cpp:

        (WebCore::Element::dir): current dir attribute state

        (WebCore::Element::computeInheritedDirection): where directionality is evaluated

        (WebCore::Element::evalContentDirectionality): where we find out directionality based on the element's content

        * dom/Element.h: new methods above

2015-03-05  Carlos Garcia Campos  <cgarcia@igalia.com>

        [SOUP] Check TLS errors as soon as they are set in the SoupMessage

Source/WebCore/css/CSSSelector.cpp

#include "CSSSelectorList.h"

#include "HTMLNames.h"

#include "SelectorPseudoTypeMap.h"

33#include "TextDirection.h"

#include <wtf/Assertions.h>

#include <wtf/HashMap.h>

#include <wtf/NeverDestroyed.h>

@@CSSSelector::PseudoElementType CSSSelector::parsePseudoElementType(const String&

    return type;

}

323

bool CSSSelector::parseDirection(const String& name, TextDirection& dir)

{

    bool valid = false;

    if (equalIgnoringCase(name, "ltr")) {

        valid = true;

        dir = LTR;

    }

    if (equalIgnoringCase(name, "rtl")) {

        valid = true;

        dir = RTL;

    }

    return valid;

}

bool CSSSelector::operator==(const CSSSelector& other) const

{

    const CSSSelector* sel1 = this;

Source/WebCore/css/CSSSelector.h

#define CSSSelector_h

#include "QualifiedName.h"

26#include "TextDirection.h"

#include "RenderStyleConstants.h"

#include <wtf/Noncopyable.h>

@@namespace WebCore {

        static PseudoElementType parsePseudoElementType(const String&);

        static PseudoId pseudoId(PseudoElementType);

#if ENABLE(CSS_SELECTORS_LEVEL4)

        static bool parseDirection(const String&, TextDirection& dir);

#endif

        // Selectors are kept in an array by CSSSelectorList. The next component of the selector is

        // the next item in the array.

Source/WebCore/css/SelectorChecker.cpp

#include "ShadowRoot.h"

#include "StyledElement.h"

#include "Text.h"

58 #include "TextDirection.h"

namespace WebCore {

@@bool SelectorChecker::checkOne(const CheckingContextWithStatus& context, PseudoI

#if ENABLE(CSS_SELECTORS_LEVEL4)

        // FIXME: Implement :dir() selector.

        case CSSSelector::PseudoClassDir:

1013 return false;

1014

            {

                TextDirection dir;

                if (!CSSSelector::parseDirection(selector->argument(), dir)) {

                    return false;

                }

                return (element->computeInheritedDirection() == dir);

            }

        // FIXME: Implement :role() selector.

        case CSSSelector::PseudoClassRole:

            return false;

Source/WebCore/dom/Element.cpp

#include "HTMLCollection.h"

#include "HTMLDocument.h"

#include "HTMLFormControlsCollection.h"

51#include "HTMLInputElement.h"

#include "HTMLLabelElement.h"

#include "HTMLNameCollection.h"

#include "HTMLOptionsCollection.h"

@@Locale& Element::locale() const

{

    return document().getCachedLocale(computeInheritedLanguage());

}

    
Element::DirAttributeState Element::dir() const

{

    static NeverDestroyed<AtomicString> ltrValue("ltr", AtomicString::ConstructFromLiteral);

    static NeverDestroyed<AtomicString> rtlValue("rtl", AtomicString::ConstructFromLiteral);

    static NeverDestroyed<AtomicString> autoValue("auto", AtomicString::ConstructFromLiteral);

    const AtomicString& value = fastGetAttribute(dirAttr);

    if (equalIgnoringCase(value, ltrValue))

        return DirLTR;

    if (equalIgnoringCase(value, rtlValue))

        return DirRTL;

    if (equalIgnoringCase(value, autoValue))

        return DirAuto;

    return DirUnknown;

}

TextDirection Element::computeInheritedDirection() const

{

    DirAttributeState d = dir();

    TextDirection td;

    if (d == DirLTR)

        return LTR;

    if (d == DirRTL)

        return RTL;

    if (is<HTMLInputElement>(*this)) {

        HTMLInputElement& input = downcast<HTMLInputElement>(const_cast<Element&>(*this));

        if (d == DirUnknown && input.isTelephoneField())

            return LTR;

        if (d == DirAuto && (input.isTextField() ||

                             input.isSearchField() ||

                             input.isTelephoneField() ||

                             input.isURLField() ||

                             input.isEmailField())) {

            if (evalContentDirectionality(td))

                return td;

        }

    } else if (is<HTMLTextAreaElement>(*this)) {

        if (d == DirAuto && evalContentDirectionality(td))

            return td;

    } else if (d == DirAuto || (d == DirUnknown && equalIgnoringCase(nodeName(), "bdi"))) {

        if (evalContentDirectionality(td)) {

            return td;

        }

    } else if (d == DirUnknown) {

        if (isDocumentNode())

            return LTR;

        if (parentElement())

            return parentElement()->computeInheritedDirection();

    }

    return LTR; // Must ASSERT we don't get here

}

bool Element::evalContentDirectionality(TextDirection& direction) const {

    bool foundDirection = false;

    UCharDirection charDirection;

    if (is<HTMLTextFormControlElement>(*this)) {

        HTMLTextFormControlElement& textElement = downcast<HTMLTextFormControlElement>(const_cast<Element&>(*this));

        bool hasStrongDirectionality;

        charDirection = textElement.value().defaultWritingDirection(&hasStrongDirectionality);

        foundDirection = true;

    } else {

        Node* node = firstChild();

        while (node) {

            // Skip bdi, script, style and text form controls.

            if (equalIgnoringCase(node->nodeName(), "bdi") || node->hasTagName(scriptTag) || node->hasTagName(styleTag)

                || (is<Element>(*node) && downcast<Element>(*node).isTextFormControl())) {

                node = NodeTraversal::nextSkippingChildren(*node, this);

                continue;

            }

            // Skip elements with valid dir attribute

            if (is<Element>(*node)) {

                Element& e = downcast<Element>(*node);

                if (e.dir() != DirUnknown) {

                    node = NodeTraversal::nextSkippingChildren(*node, this);

                    continue;

                }

            }

            if (node->isTextNode()) {

                bool hasStrongDirectionality;

                charDirection = node->textContent(true).defaultWritingDirection(&hasStrongDirectionality);

                foundDirection = true;

            }

            node = NodeTraversal::next(*node, this);

        }

    }

    if (foundDirection) {

        direction =  (charDirection == U_LEFT_TO_RIGHT)? LTR : RTL;

        return true;

    }

    return false;

}

void Element::cancelFocusAppearanceUpdate()

{

Source/WebCore/dom/Element.h

#include "ScrollTypes.h"

#include "SimulatedClickOptions.h"

#include "StyleResolveTree.h"

36#include "TextDirection.h"

namespace WebCore {

@@public:

    AtomicString computeInheritedLanguage() const;

    Locale& locale() const;

    
    enum DirAttributeState { DirLTR, DirRTL, DirAuto, DirUnknown };

    DirAttributeState dir() const;

    TextDirection computeInheritedDirection() const;

    virtual void accessKeyAction(bool /*sendToAnyEvent*/) { }

@@private:

    void unregisterNamedFlowContentElement();

    void createUniqueElementData();

661

662 bool evalContentDirectionality(TextDirection& direction) const;

    ElementRareData* elementRareData() const;

    ElementRareData& ensureElementRareData();