Convert first letter into a pseudo element.

Source/core/dom/FirstLetterPseudoElement.cpp

+/*

[leviw_travelin_and_unemployed, 2014/11/11 21:22:04]

You should be able to use the new shorter license text:

// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

[dsinclair, 2014/11/11 21:24:32]

Heh, I played this game last time. I left it as the old license because the vast
majority of this code is moved from RenderBlock. I couldn't figure out if the
new license applied to mostly new-code, or just any newly created file even if
it's mostly old code.

This seemed safer?

+ * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
+ *           (C) 1999 Antti Koivisto (koivisto@kde.org)
+ *           (C) 2007 David Smith (catfish.man@gmail.com)
+ * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
+ * Copyright (C) Research In Motion Limited 2010. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "core/dom/FirstLetterPseudoElement.h"
+
+#include "core/dom/Element.h"
+#include "core/rendering/RenderObject.h"
+#include "core/rendering/RenderObjectInlines.h"
+#include "core/rendering/RenderText.h"
+#include "core/rendering/RenderTextFragment.h"
+#include "wtf/text/WTFString.h"
+#include "wtf/unicode/icu/UnicodeIcu.h"
+
+namespace blink {
+
+using namespace WTF;
+using namespace Unicode;
+
+// 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)
+{
+    CharCategory charCategory = category(c);
+    return charCategory == Punctuation_Open
+        || charCategory == Punctuation_Close
+        || charCategory == Punctuation_InitialQuote
+        || charCategory == Punctuation_FinalQuote
+        || charCategory == Punctuation_Other;
+}
+
+static inline bool isSpaceForFirstLetter(UChar c)
+{
+    return isSpaceOrNewline(c) || c == noBreakSpace;
+}
+
+unsigned FirstLetterPseudoElement::firstLetterLength(const String& text)
+{
+    unsigned length = 0;
+    unsigned textLength = text.length();
+
+    if (textLength == 0)
+        return 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]) || length == textLength)
+        return 0;
+
+    // Account the next character for first letter.
+    length++;
+
+    // Keep looking for allowed punctuation for the :first-letter.
+    for (; length < textLength; ++length) {
+        UChar c = text[length];
+        if (!isPunctuationForFirstLetter(c))
+            break;
+    }
+    return length;
+}
+
+// Once we see any of these renderers we can stop looking for first-letter as
+// they signal the end of the first line of text.
+bool FirstLetterPseudoElement::isInvalidFirstLetterRenderer(const RenderObject* obj)
+{
+    return (obj->isBR() || (obj->isText() && toRenderText(obj)->isWordBreak()));
+}
+
+RenderObject* FirstLetterPseudoElement::firstLetterTextRenderer(const Element& element)
+{
+    RenderObject* parentRenderer = 0;
+
+    // If we are looking at a first letter element then we need to find the
+    // first letter text renderer from the parent node, and not ourselves.
+    if (element.isFirstLetterPseudoElement())
+        parentRenderer = element.parentOrShadowHostElement()->renderer();
+    else
+        parentRenderer = element.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 to the sibling.

[Julien - ping for review, 2014/11/12 21:58:51]

I don't understand this explanation: why is that correct to consider the
sibling? (I assume they both belong to the pseudo element's render tree so we
don't have lifetime issues)

[dsinclair, 2014/11/13 17:55:36]

The sibling of the first-letter renderer will be the remaining text renderer.
The tree is something like:

RenderBlock
  RenderBlock (anonymous) (first-letter renderer
     RenderTextFragment (has the letter itself)
  RenderTextFragment (the remaining text)

Even if the remaining text renderer is gone that's fine because we'll just exit
the while (firstLetterTextRenderer) check above. We deal with a null renderer
later.

Added a little bit more context to the message.

+        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.
+            RefPtr<StringImpl> str = toRenderText(firstLetterTextRenderer)->isTextFragment() ?
+                toRenderTextFragment(firstLetterTextRenderer)->completeText() :
+                toRenderText(firstLetterTextRenderer)->originalText();
+            if (firstLetterLength(str.get()) || isInvalidFirstLetterRenderer(firstLetterTextRenderer))
+                break;
+            firstLetterTextRenderer = firstLetterTextRenderer->nextSibling();
+        // FIXME: Need to track down why these conditions are needed.

[Julien - ping for review, 2014/11/12 21:58:51]

Do we need a bug?

[dsinclair, 2014/11/13 17:55:36]

Removed the comment.

+        } 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->isFlexibleBoxIncludingDeprecated() || firstLetterTextRenderer->isRenderGrid()) {
+            return nullptr;
+        } else if (firstLetterTextRenderer->style()->hasPseudoStyle(FIRST_LETTER)
+            && firstLetterTextRenderer->canHaveGeneratedChildren())  {
+            // There is a renderer further down the tree which has FIRST_LETTER set. When that node
+            // is attached we will handle setting up the first letter then.
+            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. crbug.com/422336.
+    // Should counter be on this list? What about RenderTextFragment?
+    if (!firstLetterTextRenderer || !firstLetterTextRenderer->isText() || isInvalidFirstLetterRenderer(firstLetterTextRenderer))
+        return nullptr;
+
+    return firstLetterTextRenderer;
+}
+
+FirstLetterPseudoElement::FirstLetterPseudoElement(Element* parent)
+    : PseudoElement(parent, FIRST_LETTER)
+    , m_remainingTextRenderer(nullptr)
+    , m_needsUpdate(false)
+    , m_detaching(false)
+{
+}
+
+FirstLetterPseudoElement::~FirstLetterPseudoElement()
+{
+}
+
+void FirstLetterPseudoElement::trace(Visitor* visitor)
+{
+    visitor->trace(m_remainingTextRenderer);
+    PseudoElement::trace(visitor);
+}
+
+void FirstLetterPseudoElement::setNeedsUpdate()
+{
+    m_needsUpdate = true;
+    bool neededRecalc = needsStyleRecalc();
+    setNeedsStyleRecalc(LocalStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::PseudoClass));
+
+    // If style recalc is currently executing, and we have already been recalc'd
+    // we need to tell our parent to do the recalc again because we need to
+    // re-initialize the first letter state. This can happen for things like
+    // RenderQuote where quotes processed later can effect things already styled.
+    if (document().inStyleRecalc() && !m_detaching && !neededRecalc && parentNode() && parentNode()->isElementNode())
+        toElement(parentNode())->recalcStyle(UpdatePseudoElements);
+}
+
+void FirstLetterPseudoElement::attach(const AttachContext& context)
+{
+    PseudoElement::attach(context);
+    attachFirstLetterTextRenderers();
+}
+
+void FirstLetterPseudoElement::detach(const AttachContext& context)
+{
+    m_detaching = true;

[Julien - ping for review, 2014/11/12 21:58:51]

The name of this variable is weird. I thought it would only be set during
detachment but it looks like it just tracks whether we are detached.

We should rename the variable to better match the intent. Also if it just track
if we are detaced, wouldn't renderer() serve the same purpose? (this is likely
completely off but I had to ask :))

[dsinclair, 2014/11/13 17:55:36]

I've added a reset of the variable to false at the end of the method. We need to
track if we're currently detaching because the call
m_remainingTextRenderer->setText() below will trigger a setNeedsUpdate on the
first letter, which causes things to go badly.

This guards that if we get into setNeedsUpdate while detaching we don't attempt
a recalcStyle on the parent node.

+    if (m_remainingTextRenderer) {
+        if (m_remainingTextRenderer->node()) {
+            Text* textNode = toText(m_remainingTextRenderer->node());
+            m_remainingTextRenderer->setText(textNode->dataImpl(), true);
+        }
+        m_remainingTextRenderer->setFirstLetterPseudoElement(nullptr);
+    }
+    m_remainingTextRenderer = nullptr;
+
+    PseudoElement::detach(context);
+}
+
+
+RenderStyle* FirstLetterPseudoElement::styleForFirstLetter(RenderObject* rendererContainer)
+{
+    ASSERT(rendererContainer);
+
+    RenderObject* styleContainer = parentOrShadowHostElement()->renderer();
+    ASSERT(styleContainer);
+
+    // We always force the pseudo style to recompute as the first-letter style
+    // computed by the style container may not have taken the renderers styles
+    // into account.
+    styleContainer->style()->removeCachedPseudoStyle(FIRST_LETTER);
+
+    RenderStyle* pseudoStyle = styleContainer->getCachedPseudoStyle(FIRST_LETTER, rendererContainer->firstLineStyle());
+    ASSERT(pseudoStyle);
+
+    // Force inline display (except for floating first-letters).
+    pseudoStyle->setDisplay(pseudoStyle->isFloating() ? BLOCK : INLINE);
+
+    // CSS2 says first-letter can't be positioned.
+    pseudoStyle->setPosition(StaticPosition);
+
+    return pseudoStyle;
+}
+
+void FirstLetterPseudoElement::attachFirstLetterTextRenderers()
+{
+    RenderObject* nextRenderer = FirstLetterPseudoElement::firstLetterTextRenderer(*this);
+    ASSERT(nextRenderer);
+    ASSERT(nextRenderer->isText());
+
+    // The original string is going to be either a generated content string or a DOM node's
+    // string. We want the original string before it got transformed in case first-letter has
+    // no text-transform or a different text-transform applied to it.
+    String oldText = toRenderText(nextRenderer)->isTextFragment() ? toRenderTextFragment(nextRenderer)->completeText() : toRenderText(nextRenderer)->originalText();
+    ASSERT(oldText.impl());
+
+    RenderStyle* pseudoStyle = styleForFirstLetter(nextRenderer->parent());
+    renderer()->setStyle(pseudoStyle);
+
+    // FIXME: This would already have been calculated in firstLetterRenderer. Can we pass the length through?
+    unsigned length = FirstLetterPseudoElement::firstLetterLength(oldText);
+
+    // Construct a text fragment for the text after the first letter.
+    // This text fragment might be empty.
+    RenderTextFragment* remainingText =
+        new RenderTextFragment(nextRenderer->node() ? nextRenderer->node() : &nextRenderer->document(), oldText.impl(), length, oldText.length() - length);
+    remainingText->setFirstLetterPseudoElement(this);
+    remainingText->setIsRemainingTextRenderer();
+    remainingText->setStyle(nextRenderer->style());
+
+    if (remainingText->node())
+        remainingText->node()->setRenderer(remainingText);
+
+    m_remainingTextRenderer = remainingText;
+
+    RenderObject* nextSibling = renderer()->nextSibling();
+    renderer()->parent()->addChild(remainingText, nextSibling);
+
+    // Construct text fragment for the first letter.
+    RenderTextFragment* letter = new RenderTextFragment(&nextRenderer->document(), oldText.impl(), 0, length);
+    letter->setFirstLetterPseudoElement(this);
+    letter->setStyle(pseudoStyle);
+    renderer()->addChild(letter);
+
+    nextRenderer->destroy();
+}
+
+void FirstLetterPseudoElement::didRecalcStyle(StyleRecalcChange)
+{
+    if (!renderer())
+        return;
+
+    // The renderers inside pseudo elements are anonymous so they don't get notified of recalcStyle and must have
+    // the style propagated downward manually similar to RenderObject::propagateStyleToAnonymousChildren.
+    RenderObject* renderer = this->renderer();
+    for (RenderObject* child = renderer->nextInPreOrder(renderer); child; child = child->nextInPreOrder(renderer)) {
+        // We need to re-calculate the correct style for the first letter element
+        // and then apply that to the container and the text fragment inside.
+        if (child->style()->styleType() == FIRST_LETTER && m_remainingTextRenderer) {
+            if (RenderStyle* pseudoStyle = styleForFirstLetter(m_remainingTextRenderer->parent()))
+                child->setPseudoStyle(pseudoStyle);
+            continue;
+        }
+
+        // We only manage the style for the generated content items.
+        if (!child->isText() && !child->isQuote() && !child->isImage())
+            continue;
+
+        child->setPseudoStyle(renderer->style());
+    }
+}

[Julien - ping for review, 2014/11/12 21:58:51]

It's a bit sad to have this function duplicated from PseudoElement with some
little tweaks.

[dsinclair, 2014/11/13 17:55:36]

Acknowledged.

+
+} // namespace blink