Apply the correct style to first-letter pseudo elements composed of different renderers

Source/core/rendering/RenderBlock.cpp

 /*
  * 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.
+ * Copyright (C) 2014 Samsung Electronics. 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.
@@ skipping 4082 matching lines @@
         firstLetterContainer->addChild(firstLetter, nextSibling);
     } else
         firstLetter->setStyle(pseudoStyle);
 
     for (RenderObject* genChild = firstLetter->firstChild(); genChild; genChild = genChild->nextSibling()) {
         if (genChild->isText())
             genChild->setStyle(pseudoStyle);
     }
 }
 
-static inline unsigned firstLetterLength(const String& text)
-{
-    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;
-}
-
 void RenderBlock::createFirstLetterRenderer(RenderObject* firstLetterBlock, RenderObject* currentChild, unsigned length)
 {
     ASSERT(length && currentChild->isText());
 
     RenderObject* firstLetterContainer = currentChild->parent();
     RenderStyle* pseudoStyle = styleForFirstLetter(firstLetterBlock, firstLetterContainer);
     RenderObject* firstLetter = 0;
     if (pseudoStyle->display() == INLINE)
         firstLetter = RenderInline::createAnonymous(&document());
     else
@@ skipping 24 matching lines @@
 
     // construct text fragment for the first letter
     RenderTextFragment* letter =
         new RenderTextFragment(remainingText->node() ? remainingText->node() : &remainingText->document(), oldText.impl(), 0, length);
     letter->setStyle(pseudoStyle);
     firstLetter->addChild(letter);
 
     textObj->destroy();
 }
 
+static String getRendererTextForFirstLetter(RenderObject* renderer)

[eseidel, 2014/03/26 15:31:52]

We don't normally use "get" for getters in Blink style.

+{
+    ASSERT(renderer->isText());
+
+    RenderText* textRenderer = toRenderText(renderer);
+    String result = textRenderer->originalText();
+
+    // BR and Word breaks are not allowed to be part of the first-letter
+    // pseudo element, so we don't fallback to text() in those case.
+    if (!result && !textRenderer->isBR() && !textRenderer->isWordBreak())
+        result = textRenderer->text();
+
+    return result;
+}
+
+// This helper function fills the vector of RenderObjects with the ones that would be considered
+// as part of the first-letter pseudo element and returns the number of characters in the last
+// renderer found that should be considered as part of such a pseudo element (the other renderers
+// in the Vector will be considered "in full"). Also, this function might update the firstLetterBlock
+// pointer if a lower-level node with first-letter style is found while traversing the subtree under
+// the RenderObject originally passed through that parameter.
+static unsigned findTextRenderersForFirstLetterBlock(RenderObject*& firstLetterBlock, Vector<RenderObject*>& renderers)
+{
+    String text;
+    unsigned textLength = 0;
+    unsigned length = 0;
+    unsigned previousLength = 0;
+    bool leadingSpacesChecked = false;
+    bool leadingPunctuationChecked = false;
+    bool firstLetterRenderersFound = false;
+
+    // Drill into inlines looking for the render objects to be transformed into first-letter pseudoelements.
+    RenderObject* currChild = firstLetterBlock->firstChild();
+    while (currChild) {
+        if (currChild->isText()) {
+            text = getRendererTextForFirstLetter(currChild);

[eseidel, 2014/03/26 15:31:22]

Please break this block out into its own function.   100line functions are hard
to read.

+            textLength = text.length();
+            previousLength = length;
+            length = 0;
+
+            // Early checks in case we encounter the wrong characters in the wrong place.
+            if ((leadingSpacesChecked && isSpaceForFirstLetter(text[length]))
+                || (firstLetterRenderersFound && !isPunctuationForFirstLetter(text[length])))
+                break;
+
+            if (!leadingSpacesChecked && length < textLength) {
+                while (length < textLength && isSpaceForFirstLetter(text[length]))
+                    length++;
+
+                // We now we finished checking if there are still more characters.
+                if (length < textLength)
+                    leadingSpacesChecked = true;
+            }
+
+            // If leading spaces have been checked, account now for leading punctuation.
+            if (!leadingPunctuationChecked && length < textLength) {
+                while (length < textLength && isPunctuationForFirstLetter(text[length]))
+                    length++;
+
+                // We now we finished checking if there are still more characters.
+                if (length < textLength)
+                    leadingPunctuationChecked = true;
+            }
+
+            // Now account for the next character for first letter and the trailing punctuation (if any).
+            if (!firstLetterRenderersFound && length < textLength) {
+                // Now spaces are allowed between leading punctuation and the letter.
+                if (isSpaceForFirstLetter(text[length]))
+                    break;
+
+                firstLetterRenderersFound = true;
+                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;
+            }
+
+            // If we haven't found anything with the current renderer, it does not make sense to keep
+            // checking more renderers, as they won't be part of the first-letter pseudoelement anyway.
+            if (!length)
+                break;
+
+            // Save the renderer so we can apply the right style to it later.
+            renderers.append(currChild);
+
+            // No need to keep looking if we already made a decision.
+            if (length < textLength)
+                break;
+
+            // We need to look the next object traversing the tree in preorder as if the current renderer
+            // was a leaf node (which probably is anyway) but without leaving the scope of the parent block.
+            currChild = currChild->nextInPreOrderAfterChildren(firstLetterBlock);
+        } else if (currChild->isListMarker()) {
+            currChild = currChild->nextSibling();
+        } else if (currChild->isFloatingOrOutOfFlowPositioned()) {
+            if (currChild->style()->styleType() == FIRST_LETTER) {
+                currChild = currChild->firstChild();
+                if (currChild) {
+                    // If found a floating/out-of-flow element with the first_letter
+                    // style already applied, it means it has been previously identified
+                    // and so we should discard whatever we found so far and use that.
+                    firstLetterRenderersFound = true;
+                    renderers.append(currChild);
+                }
+                break;
+            }
+            currChild = currChild->nextSibling();
+        } else if (currChild->isReplaced() || currChild->isRenderButton() || currChild->isMenuList())
+            break;
+        else if (currChild->style()->hasPseudoStyle(FIRST_LETTER) && currChild->canHaveGeneratedChildren())  {
+            // We found a lower-level node with first-letter, which supersedes the higher-level style.
+            firstLetterBlock = currChild;
+            currChild = currChild->firstChild();
+        } else
+            currChild = currChild->firstChild();
+    }
+
+    if (!firstLetterRenderersFound) {
+        // Empty the list of renderers if we did not find a correct set of them
+        // to further generate new elements to apply the first-letter style over.
+        renderers.clear();
+    } else if (!length) {
+        // If we found renderers for the first-letter and length is zero it means that the last valid
+        // renderer was added in the previous iteration of the loop, so we consider its length instead.
+        length = previousLength;
+    }
+
+    // Return the number of characters used for the first-letter pseudo element coming
+    // from the last text renderer found, needed to create the last generated renderer.
+    return renderers.isEmpty() ? 0 : length;
+}
+
 void RenderBlock::updateFirstLetter()
 {
     if (!document().styleEngine()->usesFirstLetterRules())
         return;
+
     // Don't recur
     if (style()->styleType() == FIRST_LETTER)
         return;
 
     // FIXME: We need to destroy the first-letter object if it is no longer the first child. Need to find
     // an efficient way to check for that situation though before implementing anything.
     RenderObject* firstLetterBlock = findFirstLetterBlock(this);
     if (!firstLetterBlock)
         return;
 
-    // Drill into inlines looking for our first text child.
-    RenderObject* currChild = firstLetterBlock->firstChild();
-    unsigned length = 0;
-    while (currChild) {
-        if (currChild->isText()) {
-            // FIXME: If there is leading punctuation in a different RenderText than
-            // the first letter, we'll not apply the correct style to it.
-            length = firstLetterLength(toRenderText(currChild)->originalText());
-            if (length)
-                break;
-            currChild = currChild->nextSibling();
-        } else if (currChild->isListMarker()) {
-            currChild = currChild->nextSibling();
-        } else if (currChild->isFloatingOrOutOfFlowPositioned()) {
-            if (currChild->style()->styleType() == FIRST_LETTER) {
-                currChild = currChild->firstChild();
-                break;
-            }
-            currChild = currChild->nextSibling();
-        } else if (currChild->isReplaced() || currChild->isRenderButton() || currChild->isMenuList())
-            break;
-        else if (currChild->style()->hasPseudoStyle(FIRST_LETTER) && currChild->canHaveGeneratedChildren())  {
-            // We found a lower-level node with first-letter, which supersedes the higher-level style
-            firstLetterBlock = currChild;
-            currChild = currChild->firstChild();
-        } else
-            currChild = currChild->firstChild();
-    }
-
-    if (!currChild)
+    // Find the renderers to apply the first-letter style over.
+    Vector<RenderObject*> renderers;
+    unsigned lengthForLastRenderer = findTextRenderersForFirstLetterBlock(firstLetterBlock, renderers);
+    if (renderers.isEmpty())
         return;
 
-    // If the child already has style, then it has already been created, so we just want
-    // to update it.
-    if (currChild->parent()->style()->styleType() == FIRST_LETTER) {
-        updateFirstLetterStyle(firstLetterBlock, currChild);
-        return;
+    // Create the new renderers for the first-letter pseudo elements.
+    for (Vector<RenderObject*>::const_iterator it = renderers.begin(); it != renderers.end(); ++it) {
+        RenderObject* currentRenderer = *it;
+        ASSERT(currentRenderer->isText());
+
+        // If the child already has style, then it has already been created, so we just want
+        // to update it.
+        if (currentRenderer->parent()->style()->styleType() == FIRST_LETTER) {
+            updateFirstLetterStyle(firstLetterBlock, currentRenderer);
+            continue;
+        }
+
+        // FIXME: This black-list of disallowed RenderText subclasses is fragile.
+        // Should counter be on this list? What about RenderTextFragment?
+        RenderText* textRenderer = toRenderText(currentRenderer);
+        if (!currentRenderer->isText() || currentRenderer->isBR() || textRenderer->isWordBreak())
+            continue;
+
+        // Our layout state is not valid for the repaints we are going to trigger by
+        // adding and removing children of firstLetterContainer.
+        LayoutStateDisabler layoutStateDisabler(*this);
+
+        unsigned lengthForRenderer = 0;
+        if (currentRenderer == renderers.last())
+            lengthForRenderer = lengthForLastRenderer;
+        else
+            lengthForRenderer = getRendererTextForFirstLetter(currentRenderer).length();
+
+        if (lengthForRenderer)
+            createFirstLetterRenderer(firstLetterBlock, currentRenderer, lengthForRenderer);
     }
-
-    // FIXME: This black-list of disallowed RenderText subclasses is fragile.
-    // Should counter be on this list? What about RenderTextFragment?
-    if (!currChild->isText() || currChild->isBR() || toRenderText(currChild)->isWordBreak())
-        return;
-
-    // Our layout state is not valid for the repaints we are going to trigger by
-    // adding and removing children of firstLetterContainer.
-    LayoutStateDisabler layoutStateDisabler(*this);
-
-    createFirstLetterRenderer(firstLetterBlock, currChild, length);
 }
 
 // Helper methods for obtaining the last line, computing line counts and heights for line counts
 // (crawling into blocks).
 static bool shouldCheckLines(RenderObject* obj)
 {
     return !obj->isFloatingOrOutOfFlowPositioned()
         && obj->isRenderBlock() && obj->style()->height().isAuto()
         && (!obj->isDeprecatedFlexibleBox() || obj->style()->boxOrient() == VERTICAL);
 }
@@ skipping 765 matching lines @@
 void RenderBlock::showLineTreeAndMark(const InlineBox* markedBox1, const char* markedLabel1, const InlineBox* markedBox2, const char* markedLabel2, const RenderObject* obj) const
 {
     showRenderObject();
     for (const RootInlineBox* root = firstRootBox(); root; root = root->nextRootBox())
         root->showLineTreeAndMark(markedBox1, markedLabel1, markedBox2, markedLabel2, obj, 1);
 }
 
 #endif
 
 } // namespace WebCore