Convert first letter into a pseudo element.

Source/core/dom/Element.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Peter Kelly (pmk@post.com)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012, 2013 Apple Inc. All rights reserved.
  *           (C) 2007 Eric Seidel (eric@webkit.org)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 85 matching lines @@
 #include "core/html/HTMLTableRowsCollection.h"
 #include "core/html/HTMLTemplateElement.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/page/Chrome.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/FocusController.h"
 #include "core/page/Page.h"
 #include "core/page/PointerLockController.h"
 #include "core/rendering/RenderLayer.h"
+#include "core/rendering/RenderTextFragment.h"
 #include "core/rendering/RenderView.h"
 #include "core/rendering/compositing/RenderLayerCompositor.h"
 #include "core/svg/SVGDocumentExtensions.h"
 #include "core/svg/SVGElement.h"
 #include "platform/EventDispatchForbiddenScope.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/scroll/ScrollableArea.h"
 #include "wtf/BitVector.h"
 #include "wtf/HashFunctions.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/TextPosition.h"
+#include "wtf/unicode/icu/UnicodeIcu.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 using namespace XMLNames;
 
+using namespace WTF;
+using namespace Unicode;
+
 typedef WillBeHeapVector<RefPtrWillBeMember<Attr> > AttrNodeList;
 
 static Attr* findAttrNodeInList(const AttrNodeList& attrNodeList, const QualifiedName& name)
 {
     AttrNodeList::const_iterator end = attrNodeList.end();
     for (AttrNodeList::const_iterator it = attrNodeList.begin(); it != end; ++it) {
         if ((*it)->qualifiedName() == name)
             return it->get();
     }
     return 0;
@@ skipping 1204 matching lines @@
 
     // When a shadow root exists, it does the work of attaching the children.
     if (ElementShadow* shadow = this->shadow())
         shadow->attach(context);
 
     ContainerNode::attach(context);
 
     createPseudoElementIfNeeded(AFTER);
     createPseudoElementIfNeeded(BACKDROP);
 
+    // We create the first-letter element after the :before, :after and
+    // children are attached because the first letter text could come
+    // from any of them.
+    createPseudoElementIfNeeded(FIRST_LETTER);
+
     if (hasRareData() && !renderer()) {
         if (ActiveAnimations* activeAnimations = elementRareData()->activeAnimations()) {
             activeAnimations->cssAnimations().cancel();
             activeAnimations->setAnimationStyleChange(false);
         }
     }
 }
 
 void Element::detach(const AttachContext& context)
 {
@@ skipping 139 matching lines @@
             for (ShadowRoot* root = youngestShadowRoot(); root; root = root->olderShadowRoot()) {
                 if (root->shouldCallRecalcStyle(change))
                     root->recalcStyle(change);
             }
             recalcChildStyle(change);
         }
 
         updatePseudoElement(AFTER, change);
         updatePseudoElement(BACKDROP, change);
 
+        // If our children have changed then we need to force the first-letter
+        // checks as we don't know if they effected the first letter or not.
+        // This can be seen when a child transitions from floating to
+        // non-floating we have to take it into account for the first letter.
+        updatePseudoElement(FIRST_LETTER, childNeedsStyleRecalc() ? Force : change);
+
         clearChildNeedsStyleRecalc();
     }
 
     if (hasCustomStyleCallbacks())
         didRecalcStyle(change);
 
     if (change == Reattach)
         reattachWhitespaceSiblings(nextTextSibling);
 }
 
@@ skipping 212 matching lines @@
         return;
 
     if (!style || (styleAffectedByEmpty() && (!style->emptyState() || hasChildren())))
         document().styleResolver()->ensureUpdatedRuleFeatureSet().scheduleStyleInvalidationForPseudoChange(CSSSelector::PseudoEmpty, *this);
 }
 
 void Element::childrenChanged(const ChildrenChange& change)
 {
     ContainerNode::childrenChanged(change);
 
+    if (change.isChildRemoval() && pseudoElement(FIRST_LETTER))
+        clearFirstLetterPseudoElement();

[esprehn, 2014/09/30 09:00:30]

Destroying it on every child mutation doesn't seem right, if you have:

<div><span>Text</span></div>

then the child mutations will be in the <span> and it won't have the first
letter pseudo, the div will.

[dsinclair, 2014/09/30 21:46:33]

Removed. Re-ran the layout tests with this removed and it no-longer is needed.

+
     checkForEmptyStyleChange();
     if (!change.byParser && change.isChildElementChange())
         checkForSiblingStyleChanges(change.type == ElementRemoved ? SiblingElementRemoved : SiblingElementInserted, change.siblingBeforeChange, change.siblingAfterChange);
 
     if (ElementShadow* shadow = this->shadow())
         shadow->setNeedsDistributionRecalc();
 }
 
 void Element::finishParsingChildren()
 {
@@ skipping 729 matching lines @@
     // attributes while we are iterating.
     WillBeHeapVector<RefPtrWillBeMember<Attr> > attrNodesCopy(*attrNodes);
     for (size_t i = 0; i < attrNodesCopy.size(); ++i)
         attrNodesCopy[i]->normalize();
 }
 
 void Element::updatePseudoElement(PseudoId pseudoId, StyleRecalcChange change)
 {
     ASSERT(!needsStyleRecalc());
     PseudoElement* element = pseudoElement(pseudoId);
-    if (element && (change == UpdatePseudoElements || element->shouldCallRecalcStyle(change))) {
+
+    // We have a first-letter pseudoElement, but we no longer should have one.
+    // This can happen if we change to a float, for example. We need to cleanup the
+    // first-letter pseudoElement and then fix the text the original remaining
+    // text renderer.
+    if (pseudoId == FIRST_LETTER && element && !element->firstLetterTextRenderer()) {

[esprehn, 2014/09/30 09:00:30]

Why can't we handle this in the code below?

[dsinclair, 2014/09/30 21:46:33]

Done.

Moved it into the if (change >= UpdatePseudoElements) below.

+        elementRareData()->setPseudoElement(pseudoId, nullptr);
+
+    // For first-letter we need to force the style recalc here. The first letter
+    // node's renderer needs to be forced to get a new style. This can be seen
+    // in fast/css/first-letter-nested.html when we change the font size of
+    // test_span_2.

[esprehn, 2014/09/30 09:00:30]

Why? This comment explains what you're doing but not why. This code also doesn't
seem right, if you're always going to force it when you should just always pass
Force to the caller.

[dsinclair, 2014/09/30 21:46:33]

The caller is now doing a Force if the children have changed. This will handle
the first letter.

+    } else if (element && (change == UpdatePseudoElements || element->shouldCallRecalcStyle(change)
+        || element->isFirstLetterPseudoElement())) {
+
+        // If we're updating first letter, and the current first letter renderer
+        // is not the same as the one we're currently using we need to re-create
+        // the first letter renderer.
+        if (pseudoId == FIRST_LETTER && element->firstLetterTextRenderer() != element->remainingTextRenderer()) {

[esprehn, 2014/09/30 09:00:30]

firstLetterTextRenderer() doesn't seem like something that should be on Element,
neither should remainingTextRenderer().

[dsinclair, 2014/09/30 21:46:33]

Done.

+            elementRareData()->setPseudoElement(pseudoId, nullptr);
+            createPseudoElementIfNeeded(pseudoId);
+            return;
+        }
 
         // Need to clear the cached style if the PseudoElement wants a recalc so it
         // computes a new style.
         if (element->needsStyleRecalc())
             renderer()->style()->removeCachedPseudoStyle(pseudoId);
 
         // PseudoElement styles hang off their parent element's style so if we needed
         // a style recalc we should Force one on the pseudo.
         // FIXME: We should figure out the right text sibling to pass.
         element->recalcStyle(change == UpdatePseudoElements ? Force : change);
 
         // Wait until our parent is not displayed or pseudoElementRendererIsNeeded
-        // is false, otherwise we could continously create and destroy PseudoElements
+        // is false, otherwise we could continuously create and destroy PseudoElements
         // when RenderObject::isChildAllowed on our parent returns false for the
         // PseudoElement's renderer for each style recalc.
         if (!renderer() || !pseudoElementRendererIsNeeded(renderer()->getCachedPseudoStyle(pseudoId)))
             elementRareData()->setPseudoElement(pseudoId, nullptr);
     } else if (change >= UpdatePseudoElements) {
         createPseudoElementIfNeeded(pseudoId);
     }
 }
 
 void Element::createPseudoElementIfNeeded(PseudoId pseudoId)
@@ skipping 22 matching lines @@
     return hasRareData() ? elementRareData()->pseudoElement(pseudoId) : 0;
 }
 
 RenderObject* Element::pseudoElementRenderer(PseudoId pseudoId) const
 {
     if (PseudoElement* element = pseudoElement(pseudoId))
         return element->renderer();
     return 0;
 }
 
+void Element::clearFirstLetterPseudoElement()
+{
+    elementRareData()->setPseudoElement(FIRST_LETTER, nullptr);
+    setNeedsStyleRecalc(SubtreeStyleChange);

[esprehn, 2014/09/30 09:00:30]

Woah, this is crazy, why does removing it cause a recalcStyle for the entire
subtree? That's not good. Especially not since you do this on every mutation of
the child list (which doesn't seem right either).

[dsinclair, 2014/09/30 21:46:33]

Done. This call has been removed.

+}
+
 bool Element::matches(const String& selectors, ExceptionState& exceptionState)
 {
     SelectorQuery* selectorQuery = document().selectorQueryCache().add(AtomicString(selectors), document(), exceptionState);
     if (!selectorQuery)
         return false;
     return selectorQuery->matches(*this);
 }
 
 DOMTokenList& Element::classList()
 {
@@ skipping 705 matching lines @@
     const WrapperTypeInfo* wrapperType = wrapperTypeInfo();
     v8::Handle<v8::Object> wrapper = V8DOMWrapper::createWrapper(creationContext, wrapperType, toScriptWrappableBase(), isolate);
     if (wrapper.IsEmpty())
         return v8::Handle<v8::Object>();
 
     wrapper->SetPrototype(binding->prototype());
 
     return V8DOMWrapper::associateObjectWithWrapperNonTemplate(this, wrapperType, wrapper, isolate);
 }
 
+
+// CSS 2.1 http://www.w3.org/TR/CSS21/selector.html#first-letter
+// "Punctuation (i.e, characters defined in Unicode [UNICODE] in the "open" (Ps), "close" (Pe),
+// "initial" (Pi). "final" (Pf) and "other" (Po) punctuation classes), that precedes or follows the first letter should be included"
+static inline bool isPunctuationForFirstLetter(UChar c)

[esprehn, 2014/09/30 09:00:30]

Lets put all this code in it's own class.

[dsinclair, 2014/09/30 21:46:33]

Done.

+{
+    CharCategory charCategory = category(c);
+    return charCategory == Punctuation_Open
+        || charCategory == Punctuation_Close
+        || charCategory == Punctuation_InitialQuote
+        || charCategory == Punctuation_FinalQuote
+        || charCategory == Punctuation_Other;
+}
+
+static inline bool isSpaceOrNewline(UChar c)
+{
+    // Use isASCIISpace() for basic Latin-1.
+    // This will include newlines, which aren't included in Unicode DirWS.
+    return c <= 0x7F ? WTF::isASCIISpace(c) : WTF::Unicode::direction(c) == WTF::Unicode::WhiteSpaceNeutral;
+}
+
+static inline bool isSpaceForFirstLetter(UChar c)
+{
+    return isSpaceOrNewline(c) || c == noBreakSpace;
+}
+
+unsigned Element::firstLetterLength(const String& text) const

[esprehn, 2014/09/30 09:00:30]

ditto. Own class, own files.

[dsinclair, 2014/09/30 21:46:33]

Done.

+{
+    unsigned length = 0;
+    unsigned textLength = text.length();
+
+    // Account for leading spaces first.
+    while (length < textLength && isSpaceForFirstLetter(text[length]))
+        length++;
+
+    // Now account for leading punctuation.
+    while (length < textLength && isPunctuationForFirstLetter(text[length]))
+        length++;
+
+    // Bail if we didn't find a letter before the end of the text or before a space.
+    if (isSpaceForFirstLetter(text[length]) || (textLength && length == textLength))
+        return 0;
+
+    // Account the next character for first letter.
+    length++;
+
+    // Keep looking allowed punctuation for the :first-letter.
+    for (unsigned scanLength = length; scanLength < textLength; ++scanLength) {
+        UChar c = text[scanLength];
+
+        if (!isPunctuationForFirstLetter(c))
+            break;
+
+        length = scanLength + 1;
+    }
+
+    // FIXME: If textLength is 0, length may still be 1!
+    return length;
+}
+
+RenderObject* Element::firstLetterTextRenderer() const

[esprehn, 2014/09/30 09:00:30]

ditto

[dsinclair, 2014/09/30 21:46:33]

Done.

+{
+    RenderObject* parentRenderer = renderer();
+    if (!parentRenderer
+        || !parentRenderer->style()->hasPseudoStyle(FIRST_LETTER)
+        || !parentRenderer->canHaveGeneratedChildren()
+        || !(parentRenderer->isRenderBlockFlow() || parentRenderer->isRenderButton()))
+        return nullptr;
+
+    // Drill down into our children and look for our first text child.
+    RenderObject* firstLetterTextRenderer = parentRenderer->slowFirstChild();
+    while (firstLetterTextRenderer) {
+
+        // This can be called when the first letter renderer is already in the tree. We do not
+        // want to consider that renderer for our text renderer so we go the sibling.
+        if (firstLetterTextRenderer->style() && firstLetterTextRenderer->style()->styleType() == FIRST_LETTER) {
+            firstLetterTextRenderer = firstLetterTextRenderer->nextSibling();
+
+        } else if (firstLetterTextRenderer->isText()) {
+            // FIXME: If there is leading punctuation in a different RenderText than
+            // the first letter, we'll not apply the correct style to it.
+            if (firstLetterLength(toRenderText(firstLetterTextRenderer)->originalText()))
+                break;
+            firstLetterTextRenderer = firstLetterTextRenderer->nextSibling();
+
+        } else if (firstLetterTextRenderer->isListMarker()) {
+            firstLetterTextRenderer = firstLetterTextRenderer->nextSibling();
+
+        } else if (firstLetterTextRenderer->isFloatingOrOutOfFlowPositioned()) {
+            if (firstLetterTextRenderer->style()->styleType() == FIRST_LETTER) {
+                firstLetterTextRenderer = firstLetterTextRenderer->slowFirstChild();
+                break;
+            }
+            firstLetterTextRenderer = firstLetterTextRenderer->nextSibling();
+
+        } else if (firstLetterTextRenderer->isReplaced() || firstLetterTextRenderer->isRenderButton()
+            || firstLetterTextRenderer->isMenuList()) {
+            return nullptr;
+
+        } else if (firstLetterTextRenderer->style()->hasPseudoStyle(FIRST_LETTER)
+            && firstLetterTextRenderer->canHaveGeneratedChildren())  {
+            // Let the child handle it when it's attached.
+            return nullptr;
+
+        } else {
+            firstLetterTextRenderer = firstLetterTextRenderer->slowFirstChild();
+        }
+    }
+
+    // No first letter text to display, we're done.
+    // FIXME: This black-list of disallowed RenderText subclasses is fragile.
+    // Should counter be on this list? What about RenderTextFragment?
+    if (!firstLetterTextRenderer || !firstLetterTextRenderer->isText()
+        || firstLetterTextRenderer->isBR() || toRenderText(firstLetterTextRenderer)->isWordBreak())
+        return nullptr;
+
+    return firstLetterTextRenderer;
+}
+
 } // namespace blink