Update the first letter when the first line is changed by adding a new text at its start.

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 13 matching lines @@
 #include "config.h"
 #include "core/rendering/RenderBlock.h"
 
 #include "HTMLFormElement.h"
 #include "HTMLNames.h"
 #include "core/accessibility/AXObjectCache.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/OverflowEvent.h"
 #include "core/dom/ShadowRoot.h"
+#include "core/dom/Text.h"
 #include "core/dom/WebCoreMemoryInstrumentation.h"
 #include "core/editing/Editor.h"
 #include "core/editing/FrameSelection.h"
 #include "core/page/Frame.h"
 #include "core/page/FrameView.h"
 #include "core/page/Page.h"
 #include "core/page/Settings.h"
 #include "core/platform/PODFreeListArena.h"
 #include "core/platform/graphics/FloatQuad.h"
 #include "core/platform/graphics/GraphicsContext.h"
@@ skipping 6569 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 whiteSpaceLength(PassRefPtr<StringImpl> oldText)

[esprehn, 2013/05/06 20:43:58]

Just take a String not a RefPtr<StringImpl>

+{
+    unsigned length = 0;
+    // Account for leading spaces and punctuation.
+    while (length < oldText->length() && shouldSkipForFirstLetter((*oldText)[length]))
+        length++;
+
+    // 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 < oldText->length(); ++scanLength) {
+        UChar c = (*oldText)[scanLength];
+
+        if (!shouldSkipForFirstLetter(c))
+            break;
+
+        if (isPunctuationForFirstLetter(c))
+            length = scanLength + 1;
+    }
+
+    return length;
+}
+
 void RenderBlock::createFirstLetterRenderer(RenderObject* firstLetterBlock, RenderObject* currentChild)
 {
     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.
     RefPtr<StringImpl> oldText = textObj->originalText();

[esprehn, 2013/05/06 20:43:58]

Change to String

     ASSERT(oldText);
 
     if (oldText && oldText->length() > 0) {
         unsigned length = 0;
+        length = whiteSpaceLength(oldText);
 
-        // Account for leading spaces and punctuation.
-        while (length < oldText->length() && shouldSkipForFirstLetter((*oldText)[length]))
-            length++;
-
-        // 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 < oldText->length(); ++scanLength) {
-            UChar c = (*oldText)[scanLength]; 
-            
-            if (!shouldSkipForFirstLetter(c))
-                break;
-
-            if (isPunctuationForFirstLetter(c))
-                length = scanLength + 1;
-         }
-         
         // Construct a text fragment for the text after the first letter.
         // This text fragment might be empty.
         RenderTextFragment* remainingText = 
             new (renderArena()) RenderTextFragment(textObj->node() ? textObj->node() : textObj->document(), oldText.get(), length, oldText->length() - length);
         remainingText->setStyle(textObj->style());
         if (remainingText->node())
             remainingText->node()->setRenderer(remainingText);
 
         firstLetterContainer->addChild(remainingText, textObj);
         firstLetterContainer->removeChild(textObj);
@@ skipping 19 matching lines @@
         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();
+    RenderObject* firstLetter = currChild;
+
     while (currChild) {
         if (currChild->isText())
             break;
         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 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) {
+        RenderText* remainingText = toRenderText(currChild->parent()->nextSibling());
+        // When the first line is changed by adding a new text at its start,
+        // the first letter has to be updated.
+        if (toRenderBoxModelObject(firstLetter)->firstLetterRemainingText() != remainingText) {
+            RenderText* firstLetterText = toRenderText(currChild);
+            RefPtr<StringImpl> updatedTextImp = remainingText->originalText();

[esprehn, 2013/05/06 20:43:58]

Just use String. A String is just a RefPtr to a StringImpl. There's no reason to
ever create your own RefPtr<StringImpl>

+            ASSERT(updatedTextImp);

[esprehn, 2013/05/06 20:43:58]

This assert should be inside whiteSpaceLength

+            unsigned length = 0;
+            if (updatedTextImp && updatedTextImp->length() > 0)

[esprehn, 2013/05/06 20:43:58]

This check should be inside whiteSpaceLength() and you want String isEmpty() not
an explicit length() check. Also checking if updatedTextImpl is null doesn't
make sense, you assert right above this.

unsigned length = whiteSpaceLength(updatedText)

+                length = whiteSpaceLength(updatedTextImp);
+
+            firstLetterText->setText(updatedTextImp->substring(0, length));
+            remainingText->setText(updatedTextImp->substring(length));
+
+            RenderObject* oldRemainingText = currChild->parent()->nextSibling()->nextSibling();

[esprehn, 2013/05/06 20:43:58]

This doesn't look safe at all. How do you know your parent has two siblings?

+            // Replace the previous remaining text with the original text.
+            // because it doesn't have the first letter.
+            if (oldRemainingText->isText()) {
+                RefPtr<StringImpl> oldString = toText(oldRemainingText->node())->dataImpl();

[esprehn, 2013/05/06 20:43:58]

This is going to crash if it's an anonymous text renderer like that created from
a RenderQuote or a RenderCounter.

+
+                // Before calling setText, we need to set m_firstLetter to 0 in order not to delete it.
+                if (toRenderText(oldRemainingText)->isTextFragment())
+                    toRenderTextFragment(oldRemainingText)->setFirstLetter(0);
+
+                toRenderText(oldRemainingText)->setText(oldString);
+            }
+            toRenderBoxModelObject(firstLetter)->setFirstLetterRemainingText(remainingText);
+        }
+
         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());
@@ skipping 1373 matching lines @@
 {
     memoryInstrumentation->addRootObject(gColumnInfoMap, WebCoreMemoryTypes::RenderingStructures);
     memoryInstrumentation->addRootObject(gPositionedDescendantsMap, WebCoreMemoryTypes::RenderingStructures);
     memoryInstrumentation->addRootObject(gPercentHeightDescendantsMap, WebCoreMemoryTypes::RenderingStructures);
     memoryInstrumentation->addRootObject(gPositionedContainerMap, WebCoreMemoryTypes::RenderingStructures);
     memoryInstrumentation->addRootObject(gPercentHeightContainerMap, WebCoreMemoryTypes::RenderingStructures);
     memoryInstrumentation->addRootObject(gDelayedUpdateScrollInfoSet, WebCoreMemoryTypes::RenderingStructures);
 }
 
 } // namespace WebCore