Avoid creating first-letter RenderTextFragments for unsuitable text nodes

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.
  *
  * 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
@@ skipping 5723 matching lines @@
 }
 
 static inline unsigned firstLetterLength(const String& text)
 {
     unsigned length = 0;
 
     // Account for leading spaces and punctuation.
     while (length < text.length() && shouldSkipForFirstLetter((text)[length]))
         length++;
 
+    // Bail if we didn't find a letter
+    if (text.length() && length == text.length())

[eseidel, 2013/10/07 22:27:25]

So when you just have <div>F<div> and a first-letter style, are we still going
to correctly style the F?

[leviw_travelin_and_unemployed, 2013/10/07 22:33:19]

Yup :)

In that case length will simply be 0 here. We only increment the length pointer
when the characters return true for shouldSkipForFirstLetter.

+        return 0;
+
     // Account for first letter.
     length++;
 
     // Keep looking for whitespace and allowed punctuation, but avoid
     // accumulating just whitespace into the :first-letter.
     for (unsigned scanLength = length; scanLength < text.length(); ++scanLength) {
         UChar c = (text)[scanLength];
 
         if (!shouldSkipForFirstLetter(c))
             break;
 
         if (isPunctuationForFirstLetter(c))
             length = scanLength + 1;
     }
 
     return length;
 }
 
-void RenderBlock::createFirstLetterRenderer(RenderObject* firstLetterBlock, RenderObject* currentChild)
+void RenderBlock::createFirstLetterRenderer(RenderObject* firstLetterBlock, RenderObject* currentChild, unsigned length)
 {
+    ASSERT(length);
+    ASSERT(currentChild->isText() && !toRenderText(currentChild)->isTextFragment());
+
     RenderObject* firstLetterContainer = currentChild->parent();
     RenderStyle* pseudoStyle = styleForFirstLetter(firstLetterBlock, firstLetterContainer);
     RenderObject* firstLetter = 0;
     if (pseudoStyle->display() == INLINE)
         firstLetter = RenderInline::createAnonymous(&document());
     else
         firstLetter = RenderBlock::createAnonymous(&document());
     firstLetter->setStyle(pseudoStyle);
     firstLetterContainer->addChild(firstLetter, currentChild);
 
     RenderText* textObj = toRenderText(currentChild);
 
     // 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 = textObj->originalText();
     ASSERT(oldText.impl());
 
-    unsigned length = firstLetterLength(oldText);
-
-    if (!length)
-        return;
-
     // Construct a text fragment for the text after the first letter.
     // This text fragment might be empty.
     RenderTextFragment* remainingText =
         new RenderTextFragment(textObj->node() ? textObj->node() : &textObj->document(), oldText.impl(), length, oldText.length() - length);
     remainingText->setStyle(textObj->style());
     if (remainingText->node())
         remainingText->node()->setRenderer(remainingText);
 
     firstLetterContainer->addChild(remainingText, textObj);
     firstLetterContainer->removeChild(textObj);
@@ skipping 16 matching lines @@
     // Don't recur
     if (style()->styleType() == FIRST_LETTER)
         return;
 
     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())
-            break;
-        if (currChild->isListMarker())
+        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->isFloatingOrOutOfFlowPositioned()) {
+        } 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)
         return;
 
     if (currChild->parent()->style()->styleType() == FIRST_LETTER) {
         // Destroy the first-letter object if it is no longer the first child.
         RenderObject* remainingText = currChild->parent()->nextSibling();
         if (remainingText && currChild->node() != remainingText->node()) {
             if (!remainingText->isText() || remainingText->isBR())
                 return;
 
+            RenderText* newFirstText = toRenderText(remainingText);
+            length = firstLetterLength(newFirstText->originalText());
+
+            if (!length)
+                return;
+
             LayoutStateDisabler layoutStateDisabler(view());
 
             if (RenderObject* oldRemainingText = toRenderBoxModelObject(currChild->parent())->firstLetterRemainingText())
                 toRenderText(oldRemainingText)->setText(toText(oldRemainingText->node())->data().impl());
 
-            createFirstLetterRenderer(firstLetterBlock, remainingText);
+            createFirstLetterRenderer(firstLetterBlock, newFirstText, length);
             return;
         }
 
         // If the child already has style, then it has already been created, so we just want
         // to update it.
         updateFirstLetterStyle(firstLetterBlock, currChild);
         return;
     }
 
     if (!currChild->isText() || currChild->isBR())
         return;
 
     // Our layout state is not valid for the repaints we are going to trigger by
     // adding and removing children of firstLetterContainer.
     LayoutStateDisabler layoutStateDisabler(view());
 
-    createFirstLetterRenderer(firstLetterBlock, currChild);
+    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->isRunIn()
         && obj->isRenderBlock() && obj->style()->height().isAuto()
         && (!obj->isDeprecatedFlexibleBox() || obj->style()->boxOrient() == VERTICAL);
 }
@@ skipping 928 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