Return correct length for firstLetterLength.

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 3616 matching lines @@
         if (genChild->isText())
             genChild->setStyle(pseudoStyle);
     }
 }
 
 static inline unsigned 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]) || (textLength && length == textLength))
+    if (isSpaceForFirstLetter(text[length]) || 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, RenderText& currentChild, unsigned length)
 {
     ASSERT(length);
 
     RenderObject* firstLetterContainer = currentChild.parent();
     RenderStyle* pseudoStyle = styleForFirstLetter(firstLetterBlock, firstLetterContainer);
     RenderBoxModelObject* firstLetter = 0;
@@ skipping 30 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);
 
     currentChild.destroy();
 }
 
+// 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 RenderBlock::isInvalidFirstLetterRenderer(RenderObject* obj) const
+{
+    return (obj->isBR() || (obj->isText() && toRenderText(obj)->isWordBreak()));
+}
+
 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->slowFirstChild();
     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)
+            if (length || isInvalidFirstLetterRenderer(currChild))
                 break;
             currChild = currChild->nextSibling();
         } else if (currChild->isListMarker()) {
             currChild = currChild->nextSibling();
         } else if (currChild->isFloatingOrOutOfFlowPositioned()) {
             if (currChild->style()->styleType() == FIRST_LETTER) {
                 currChild = currChild->slowFirstChild();
                 break;
             }
             currChild = currChild->nextSibling();
@@ skipping 13 matching lines @@
 
     // 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;
     }
 
     // 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())
+    if (!currChild->isText() || isInvalidFirstLetterRenderer(currChild))
         return;
 
     createFirstLetterRenderer(firstLetterBlock, toRenderText(*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()
@@ skipping 581 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 blink